ase-task-condense · diff

git:20260813.5985917 to git:20260906.93f7bf9

7 added, 4 removed. Audit A to A.

---

name: ase-task-condense

argument-hint: "[--help|-h] [--next|-n <option>[,...]] [<id>]"

description: >

Condense the current or given task plan by compressing its wording.

Use when the user calls to "condense", "compress", "shrink" or

"shorten" the "task", "plan", "spec", or "specification".

user-invocable: true

disable-model-invocation: false

effort: high

---

@${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

</purpose>

<expand name="getopt"

arg1="ase-task-condense"

$ARGUMENTS

</expand>

*Condense* the task plan by removing fluff while preserving all

semantics exactly.

</objective>

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

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

Procedure

---------

Set <args></args> (set args to empty).

Set <args>--int-reuse-task</args>.

</if>

<if condition="<getopt-option-next/> is not equal `none`">

Set <args><args/> --next <getopt-option-next/></args>

</if>

</define>

1. **Determine Task:**

1. Set <instruction><getopt-arguments/></instruction> initially, with any

leading and trailing whitespace stripped.

Inherit the always existing <ase-task-id/> from the current context.

Inherit the always existing <ase-session-id/> from the current context.

Do not output anything.

2. React on task id:

2. **Determine Operation:**

1. Determine the current task plan content:

Set <content-before><task-content/></content-before> (remember the

loaded plan content for the strictly-shorter check in step 3).

<if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">

Set <timestamp-created><text/></timestamp-created> (extract the

original creation timestamp so it can be re-inserted unchanged

into the condensed <task-content/> in step 3).

</if>

2. <if condition="<task-content/> 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.

</if>

3. **Condense Task Plan:**

1. *Apply the condense ruleset* to <task-content/>, producing a shorter

<task-content/>. 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 <format/>

structure (the frontmatter block with its `Id:`, `Created:`,

`Modified:`, `Status:`, `Properties:`, and `Kind:` keys,

the headings `#`/`##`, all

three `## CONTEXT`, `## CHANGES`, and `## VERIFICATION`

sections, and the `- **<aspect/>**:` bullet labels), all *code spans* and

code blocks, technical terms, file paths, identifiers,

numbers, severities (`LOW`/`MEDIUM`/`HIGH`/`ACCEPTED`), and

the `*<aspect/>*` emphasis highlighting convention.

2. *Compress free-text only* (the `**WHAT**`/`**WHY**` prose and

each bullet's `<specification/>` 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 ~100-character-

per-line convention of the plan <format/>, but *never*

break a line *inside* an inline code span.

- *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*: compare the condensed <task-content/>

- against <content-before/>, without counting words.

+ 2. *Persist only if smaller*: call the `ase_text_metric(text:

+ "<text/>")` tool of the `ase` MCP server once for the condensed

+ <task-content/> and once for <content-before/>, and take the

+ `chars` field of each result, so the comparison rests on a

+ *measured* length instead of an estimate.

- - <if condition="the condensed <task-content/> is strictly shorter than <content-before/>">

+ - <if condition="the condensed <task-content/> has strictly fewer `chars` than <content-before/>">

</if>

- - <if condition="the condensed <task-content/> is NOT strictly shorter than <content-before/>">

+ - <if condition="the condensed <task-content/> has NOT strictly fewer `chars` than <content-before/>">

Do *not* save and do *not* bump the timestamp. Set

<task-content><content-before/></task-content> (keep the

*unchanged* stored plan, discard the condensed one).

Only output the following <template/>:

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan already condensed**

</template>

</if>

4. **Decide Next Step:**

1. *Determine next step*:

<expand name="task-next-select"

arg1="ase-task-condense"

arg2="DONE|EDIT|IMPLEMENT|PREFLIGHT">

Next Step: How would you like to proceed with the plan?

DONE: Stop processing.

EDIT: Hand off plan to editing.

PREFLIGHT: Hand off plan to pre-flighting.

IMPLEMENT: Hand off plan to implementation.

</expand>

2. Check the tool <result/> and dispatch accordingly:

- If <result/> is `DONE` or `CANCEL`:

Only output the following <template/> and then *STOP*.

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- done**

</template>

- If <result/> is `EDIT`:

Only output the following <template/> and then call the

tool `Skill(skill: "ase:ase-task-edit", args: "<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: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to edit**

</template>

- If <result/> is `IMPLEMENT`:

Only output the following <template/> and then call the

`Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool

to *apply* the plan.

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to implementation**

</template>

- If <result/> is `PREFLIGHT`:

Only output the following <template/> and then call the

`Skill(skill: "ase:ase-task-preflight", args: "<args/>")` tool

to *apply* the plan.

⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to pre-flight**

</template>