# Ase Task Condense

> >

- **Type:** Skill
- **Install:** `agentstack add skill-rse-ase-ase-task-condense`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [rse](https://agentstack.voostack.com/s/rse)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [rse](https://github.com/rse)
- **Source:** https://github.com/rse/ase/tree/master/plugin/skills/ase-task-condense
- **Website:** https://ase.tools

## Install

```sh
agentstack add skill-rse-ase-ase-task-condense
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

Condense a Task Plan

    $ARGUMENTS

*Condense* the task plan by removing fluff while preserving all
semantics exactly.

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md

Procedure
---------

1.  **Determine Task:**

    1.  Set  initially.
        Inherit the always existing  from the current context.
        Inherit the always existing  from the current context.
        Do not output anything.

    2.  React on task id:

        1.   matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
            ">
            Set  (set task
            id to instruction) and  (set
            instruction empty), call the `ase_task_id(id: "",
            session: "")` tool from the `ase` MCP
            server to switch the task, and then only output the
            following :

            
            ⧉ **ASE**: ◉ task: ****, ▶ status: **task given**
            
            

        2.   is NOT empty">
            The argument is neither empty nor a valid task id. As this
            skill only accepts an optional `[]` argument and *never*
            a free-text instruction, only output the following 
            and then immediately *STOP* processing the entire current skill:

            
            ⧉ **ASE**: ☻ skill: **ase-task-condense**, ▶ ERROR: expected single `[]` argument
            
            

2.  **Determine Operation:**

    1.  Call the `ase_task_load(id: "")` tool of the `ase` MCP
        server to load the current task plan content and set  to
        the `text` output field of the `ase_task_load` tool call.

        -   If  starts with `ERROR:` or `WARNING:`:
            Set  (set content to empty).
            Set  to "0".

        -   If  starts NOT with `ERROR:` and NOT with `WARNING:`:
            Set  (set content to text).
            Calculate the number of words  of .

        Set  (remember the loaded
        word count for the strictly-smaller check in step 3).

         contains '⎈   Created:  '">
        Set  (extract the
        original creation timestamp so it can be re-inserted unchanged
        into the condensed  in step 3).
        

        Only output the following :

        
        ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan loaded**
        

    2.   is empty">
        Complain and tell the user to use the `ase-code-resolve`,
        `ase-code-refactor`, `ase-code-craft`, or `ase-task-edit` skills
        first to create a task plan. Then immediately stop processing
        this skill.
        

3.  **Condense Task Plan:**

    1.  *Apply the condense ruleset* to , producing a shorter
        . The goal is to make the plan require as *little
        reading* as possible while all semantics remain *fully preserved
        and unchanged*. Honor the following ruleset *strictly*:

        1.  *Preserve-exactly (never alter)*: the plan 
            structure (the headings `#`/`##`, all three `##  CONTEXT`,
            `##  CHANGES`, and `##  VERIFICATION` sections, the
            `Created:`/`Modified:` lines, and
            the `- ****:` bullet labels), all *code spans* and
            code blocks, technical terms, file paths, identifiers,
            numbers, severities (`LOW`/`MEDIUM`/`HIGH`/`ACCEPTED`), and
            the `**` emphasis highlighting convention.

        2.  *Compress free-text only* (the `**WHAT**`/`**WHY**` prose and
            each bullet's `` text):
            -   *Drop* filler ("just", "really", "basically", "simply"),
                pleasantries, and hedging ("I think", "maybe", "perhaps").
            -   *Use* shorter synonyms and common abbreviations.
            -   *Use* `→` for causality and `-` for short subsequent facts.
            -   *Drop* articles ("a", "an", "the") and *replace*
                conjunctions with short separate clauses where this
                shortens the text without introducing ambiguity.
            -   *Re-wrap* the shortened free-text to the ~120-character-
                per-line convention.
            -   *Merge* genuinely-redundant bullets (the same aspect
                restated) and *drop* pure duplication - but *only* when
                truly redundant; *never* lose a distinct aspect.

        3.  *Persona override*: this condense ruleset *always wins* for
            the plan content. This ruleset-based compression is applied
            *regardless* of the currently active session persona style.

        4.  *Hard guardrail - semantics preserved EXACTLY*: condensing
            *only* shortens wording. It *MUST NOT* drop, merge (except
            truly-redundant bullets per sub-item 2), reorder, or alter
            *any* factual claim, requirement, file path, rule, or
            example. If a shortening would change meaning, *keep the
            longer wording*.

    2.  *Persist only if smaller*: calculate the number of words 
        of the condensed .

        -    is strictly smaller than ">
            Update  with the current time in
            ISO-style format, which has to be determined by calling
            the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool
            of the `ase` MCP server and use the `text` field of
            its response. Keep the original ,
            re-insert the current  and the refreshed
             into .

            Call the `ase_task_save(id: "", text:
            "")` tool of the `ase` MCP server to save the
            condensed task plan content. Do not output anything related
            to this MCP call except the following :

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan condensed**
            
            

        -    is NOT strictly smaller than ">
            Do *not* save and do *not* bump the timestamp. Only output
            the following :

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan already condensed**
            
            

4.  **Decide Next Step:**

    1.  *Determine next step*:

        -   If  is not equal to `none`:
            Treat  as a comma-separated chronological
            list of pre-selected next-step tokens. *Split* it on `,`,
            take the *first* token as , and store the remaining
            tokens (joined back with `,`, or `none` if empty) into
             so downstream skills can consume the tail.

            -   If  matches the regex `^(DONE|EDIT|IMPLEMENT|PREFLIGHT)$`:
                Honor the pre-selected token.
                Set .

            -   else:
                Only output the following  and then immediately
                *STOP* processing the entire current skill:

                
                ⧉ **ASE**: ☻ skill: **ase-task-condense**, ▶ ERROR: invalid `--next` token: ****
                

        -   If  is equal to `none`:

            In the following, you *MUST* *NOT* use your built-in
             tool! Instead, you *MUST* just show a
            custom dialog according to the expanded `custom-dialog`
            definition. You *MUST* closely follow this definition:

            
                Next Step: How would you like to proceed with the plan?
                DONE: Stop processing.
                EDIT: Hand off plan to editing.
                IMPLEMENT: Hand off plan to implementation.
                PREFLIGHT: Hand off plan to pre-flighting.
            

    2.  Check the tool  and dispatch accordingly:

        -   If  is `DONE` or `CANCEL`:
            Only output the following  and then *STOP*.

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan condensed -- done**
            

        -   If  is `EDIT`:
            Set  (set args to empty).
            
                Set --int-reuse-task.
            
             is not equal `none`">
                Set  --next 
            
            Only output the following  and then call the
            tool `Skill(skill: "ase:ase-task-edit", args: "")`
            to invoke the `ase:ase-task-edit` skill in order to *edit*
            the condensed plan. Immediately stop processing the current
            skill once the `Skill` tool was used.

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan condensed -- hand-off to edit**
            

        -   If  is `IMPLEMENT`:
            Set  (set args to empty).
            
                Set --int-reuse-task.
            
             is not equal `none`">
                Set  --next 
            
            Only output the following  and then call the
            `Skill(skill: "ase:ase-task-implement", args: "")` tool
            to *apply* the plan.

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan condensed -- hand-off to implementation**
            

        -   If  is `PREFLIGHT`:
            Set  (set args to empty).
            
                Set --int-reuse-task.
            
             is not equal `none`">
                Set  --next 
            
            Only output the following  and then call the
            `Skill(skill: "ase:ase-task-preflight", args: "")` tool
            to *apply* the plan.

            
            ⧉ **ASE**: ◉ task: ****, ✪ plan: **** words, ▶ status: **plan condensed -- hand-off to pre-flight**

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [rse](https://github.com/rse)
- **Source:** [rse/ase](https://github.com/rse/ase)
- **License:** Apache-2.0
- **Homepage:** https://ase.tools

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-rse-ase-ase-task-condense
- Seller: https://agentstack.voostack.com/s/rse
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
