ase-task-condense · git:20260906.93f7bf9 · 2026-09-06 · sha256 b28ed000580b489f
ase-task-condense git:20260906.93f7bf9A
Immutable. This exact content is served forever at /api/v1/blob/b28ed000580b489f.
---
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
<purpose name="ase-task-condense">
Condense a Task Plan
</purpose>
<expand name="getopt"
arg1="ase-task-condense"
arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)... --int-reuse-task">
$ARGUMENTS
</expand>
<objective>
*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
---------
<define name="handoff-args">
Set <args></args> (set args to empty).
<if condition="the condensed plan was saved via `ase_task_save` in step 3">
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:
<expand name="task-react-id" arg1="ase-task-condense"></expand>
2. **Determine Operation:**
1. Determine the current task plan content:
<expand name="task-load-content"></expand>
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*: 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/> has strictly fewer `chars` than <content-before/>">
<expand name="task-save-content" arg1="plan condensed"></expand>
</if>
- <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/>:
<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*.
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- done**
</template>
- If <result/> is `EDIT`:
<expand name="handoff-args"/>
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.
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to edit**
</template>
- If <result/> is `IMPLEMENT`:
<expand name="handoff-args"/>
Only output the following <template/> and then call the
`Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool
to *apply* the plan.
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to implementation**
</template>
- If <result/> is `PREFLIGHT`:
<expand name="handoff-args"/>
Only output the following <template/> and then call the
`Skill(skill: "ase:ase-task-preflight", args: "<args/>")` tool
to *apply* the plan.
<template>
⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to pre-flight**
</template>