@rse/ase 0.9.0 → 0.9.1

package/plugin/meta/ase-skill.md

@@ -202,7 +202,9 @@ Template Patterns
 -   When `<ase-tpl-head/>` (no title attribute) should be expanded, use:
 
     <template>
+
     ╭──────────────────────────────────────────────────────────────────────┈┈┈┈┈┈┈┈┈┈
+
     </template>
 
 -   When `<ase-tpl-head title="<title/>"/>` should be expanded, use
@@ -210,13 +212,17 @@ Template Patterns
     the "─" character repeated (70 - 16 - length("<title/>")) times):
 
     <template>
+
     ╭────━━━━**(** `<title/>` **)**━━━━────<bar/>┈┈┈┈┈┈┈┈┈┈
+
     </template>
 
 -   When `<ase-tpl-foot/>` (no title attribute) should be expanded, use:
 
     <template>
+
     ╰──────────────────────────────────────────────────────────────────────┈┈┈┈┈┈┈┈┈┈
+
     </template>
 
 -   When `<ase-tpl-foot title="<title/>"/>` should be expanded, use
@@ -224,7 +230,9 @@ Template Patterns
     the "─" character repeated (70 - 16 - length("<title/>")) times):
 
     <template>
+
     ╰────━━━━**(** `<title/>` **)**━━━━────<bar/>┈┈┈┈┈┈┈┈┈┈
+
     </template>
 
 -   When `<ase-tpl-bullet-secondary/>` should be expanded, use:

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.0",
+    "version":                              "0.9.1",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-code-craft/SKILL.md

@@ -217,9 +217,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
         Hints:
 
-        -   Give a short one-sentence <summary/> of the feature approach plus
-            *precise* and *brief* feature information. Try to keep the
-            number of bullet points (●) in the range of 1-4.
+        -   Give a short one-sentence <summary/> of the feature
+            approach plus *precise* and *ultra brief and concise*
+            feature information. Try to keep the number of bullet points
+            (●) in the range of 1-4.
 
         -   In case of a *complex feature situation* only, visualize
             it with an optional diagram <optional-diagram/> by building

package/plugin/skills/ase-code-refactor/SKILL.md

@@ -207,9 +207,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
         Hints:
 
-        -   Give a short one-sentence <summary/> of the refactoring approach plus
-            *precise* and *brief* refactoring information. Try to keep the
-            number of bullet points (●) in the range of 1-4.
+        -   Give a short one-sentence <summary/> of the refactoring
+            approach plus *precise* and *ultra brief and concise*
+            refactoring information. Try to keep the number of bullet
+            points (●) in the range of 1-4.
 
         -   In case of a *complex refactoring situation* only,
             visualize it with an optional diagram <optional-diagram/>

package/plugin/skills/ase-code-resolve/SKILL.md

@@ -256,9 +256,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
         Hints:
 
-        -   Give a short one-sentence <summary/> of the resolution approach plus
-            *precise* and *brief* resolution information. Try to keep the
-            number of bullet points (●) in the range of 1-4.
+        -   Give a short one-sentence <summary/> of the resolution
+            approach plus *precise* and *ultra brief and concise*
+            resolution information. Try to keep the number of bullet
+            points (●) in the range of 1-4.
 
         -   In case of a *complex resolution situation* only,
             visualize it with an optional diagram <optional-diagram/>

package/plugin/skills/ase-meta-brainstorm/SKILL.md

@@ -114,7 +114,7 @@ Honor the following tenets throughout the brainstorming:
                 <answer-M-1/>: (first grounded candidate answer)
                 <answer-M-2/>: (second grounded candidate answer)
                 <answer-M-3/>: (third grounded candidate answer)
-                <answer-M-4/>: (forth grounded candidate answer)
+                <answer-M-4/>: (fourth grounded candidate answer)
             </expand>
 
         4.  Output the following <template/>:
@@ -164,7 +164,7 @@ Honor the following tenets throughout the brainstorming:
 4.  <step id="STEP 4: Converge Idea Space">
 
     Converge the candidate ideas <idea-N/> into a smaller, structured
-    sets and finally into a recommendation.
+    set and finally into a recommendation.
 
     1.  *Cluster*: group the candidate ideas into <c/> coherent clusters
         <cluster-C/> (a short 1-4 word label, C=1...</c>), collapsing

package/plugin/skills/ase-task-condense/SKILL.md

@@ -0,0 +1,267 @@
+---
+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
+
+<skill name="ase-task-condense">
+Condense a Task Plan
+</skill>
+
+<expand name="getopt"
+    arg1="ase-task-condense"
+    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)...">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Condense* the task plan by removing fluff while preserving all
+semantics exactly.
+</objective>
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
+
+Procedure
+---------
+
+You *MUST* follow the following numbered items *strictly* *sequentially*!
+You *MUST* not skip any numbered item during processing!
+
+You *MUST* *NOT* output anything in this entire procedure, *except* when
+explicitly requested by this procedure via outputs based on a <template/>!
+
+1.  **Determine Task:**
+
+    1.  Set <instruction><getopt-arguments/></instruction> initially.
+        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:
+
+        1.  <if condition="
+                <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
+            ">
+            Set <ase-task-id><instruction/></ase-task-id> (set task
+            id to instruction) and <instruction></instruction> (set
+            instruction empty), call the `ase_task_id(id: "<ase-task-id/>",
+            session: "<ase-session-id/>")` tool from the `ase` MCP
+            server to switch the task, and then only output the
+            following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
+            </template>
+            </if>
+
+        2.  else <if condition="<instruction/> is NOT empty">
+            The argument is neither empty nor a valid task id. As this
+            skill only accepts an optional `[<id>]` argument and *never*
+            a free-text instruction, only output the following <template/>
+            and then immediately *STOP* processing the entire current skill:
+
+            <template>
+            ⧉ **ASE**: ☻ skill: **ase-task-condense**, ▶ ERROR: expected single `[<id>]` argument
+            </template>
+            </if>
+
+2.  **Determine Operation:**
+
+    1.  Call the `ase_task_load(id: "<ase-task-id/>")` tool of the `ase` MCP
+        server to load the current task plan content and set <text/> to
+        the `text` output field of the `ase_task_load` tool call.
+
+        -   If <text/> starts with `ERROR:` or `WARNING:`:
+            Set <content></content> (set content to empty).
+            Set <words/> to "0".
+
+        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
+            Set <content><text/></content> (set content to text).
+            Calculate the number of words <words/> of <content/>.
+
+        Set <words-before><words/></words-before> (remember the loaded
+        word count for the strictly-smaller check in step 3).
+
+        Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan loaded**
+        </template>
+
+    2.  <if condition="<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 <content/>, producing a shorter
+        <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 headings `#`/`##`, the `※`/`◉`/`✪` markers,
+            all three `## ※ CONTEXT`, `## ※ CHANGES`, and `## ※
+            VERIFICATION` sections, the `created:`/`modified:` line, 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 ~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 <words/>
+        of the condensed <content/>.
+
+        -   <if condition="<words/> is strictly smaller than <words-before/>">
+            Update <timestamp-modified/> 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 <timestamp-created/>,
+            re-insert the current <ase-task-id/> and the refreshed
+            <timestamp-modified/> into <content/>.
+
+            Call the `ase_task_save(id: "<ase-task-id/>", text:
+            "<content/>")` 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 <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed**
+            </template>
+            </if>
+
+        -   <if condition="<words/> is NOT strictly smaller than <words-before/>">
+            Do *not* save and do *not* bump the timestamp. Only output
+            the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan already condensed**
+            </template>
+            </if>
+
+4.  **Decide Next Step:**
+
+    1.  *Determine next step*:
+
+        -   If <getopt-option-next/> is not equal to `none`:
+            Treat <getopt-option-next/> as a comma-separated chronological
+            list of pre-selected next-step tokens. *Split* it on `,`,
+            take the *first* token as <head/>, and store the remaining
+            tokens (joined back with `,`, or `none` if empty) into
+            <getopt-option-next/> so downstream skills can consume the tail.
+
+            -   If <head/> matches the regex `^(DONE|EDIT|IMPLEMENT|PREFLIGHT)$`:
+                Honor the pre-selected token.
+                Set <result><head/></result>.
+
+            -   else:
+                Only output the following <template/> and then immediately
+                *STOP* processing the entire current skill:
+
+                <template>
+                ⧉ **ASE**: ☻ skill: **ase-task-condense**, ▶ ERROR: invalid `--next` token: **<head/>**
+                </template>
+
+        -   If <getopt-option-next/> is equal to `none`:
+            Let the *user interactively choose* what to do as the next step.
+
+            <expand name="user-dialog">
+                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.
+            </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/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- done**
+            </template>
+
+        -   If <result/> is `EDIT`:
+            Set <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            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/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- hand-off to edit**
+            </template>
+
+        -   If <result/> is `IMPLEMENT`:
+            Set <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            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/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- hand-off to implementation**
+            </template>
+
+        -   If <result/> is `PREFLIGHT`:
+            Set <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            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/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- hand-off to pre-flight**
+            </template>

package/plugin/skills/ase-task-condense/help.md

@@ -0,0 +1,77 @@
+
+##  NAME
+
+`ase-task-condense` - Condense a Task Plan
+
+##  SYNOPSIS
+
+`ase-task-condense`
+    [`--help`|`-h`]
+    [`--next`|`-n` *option*[,...]]
+    [*id*]
+
+##  DESCRIPTION
+
+The `ase-task-condense` skill *compresses* the wording of an existing
+task plan to make it require as little reading as possible, while
+keeping *all semantics fully preserved and unchanged*. It loads the
+current (or given) plan, applies a self-contained, telegrapher-like
+"remove-fluff" ruleset to the *free-text* parts only (the `**WHAT**` /
+`**WHY**` prose and each bullet's specification text), and writes the
+shorter plan back via `ase_task_save`.
+
+The plan *structure* is never altered: all headings, section markers,
+`- **<aspect>**:` bullet labels, code spans, technical terms, file
+paths, numbers, and severities are kept exactly. Only genuinely
+redundant bullets may be merged, and a shortening that would change
+meaning is always rejected in favor of the longer wording. The condense
+ruleset *overrides* the active session persona, so the plan is compressed
+telegrapher-like even under the `writer` persona.
+
+The plan is saved *only* when condensing actually makes it smaller; if no
+further reduction is possible, the plan is left untouched (including its
+`✎ modified:` timestamp) and reported as *already condensed*.
+
+After condensing, the user is asked whether to stop or hand off to
+`ase-task-edit`, `ase-task-implement`, or `ase-task-preflight`, unless
+`--next` pre-selects this choice.
+
+##  OPTIONS
+
+`--next`|`-n` *option*[,...]:
+    Automatically answer the user dialog for the next step. *option*
+    is a single token or a *comma-separated chronological list* of
+    tokens; the *first* token is consumed by this skill, and any
+    remaining tokens are *forwarded* (via `--next`) to the downstream
+    skill so an entire pipeline can be pre-scripted in one shot.
+    Recognized tokens at this skill: `none` (default, interactive
+    answer required), `DONE` (stop), `EDIT` (hand off to
+    `ase-task-edit`), `IMPLEMENT` (hand off to `ase-task-implement`),
+    or `PREFLIGHT` (hand off to `ase-task-preflight`). Example: `--next
+    EDIT,DONE` condenses, hands off to editing, and the editing loop will
+    exit immediately.
+
+##  ARGUMENTS
+
+*id*:
+    The unique identifier of the task whose plan should be condensed.
+    If omitted, the *current* task id is used.
+
+##  EXAMPLES
+
+Condense the current task plan:
+
+```text
+❯ /ase-task-condense
+```
+
+Condense a specific task and hand off to editing:
+
+```text
+❯ /ase-task-condense --next EDIT hello
+```
+
+##  SEE ALSO
+
+`ase-task-edit`, `ase-task-reboot`, `ase-task-view`,
+`ase-task-rename`, `ase-task-delete`.

package/plugin/skills/ase-task-edit/SKILL.md

@@ -23,7 +23,7 @@ Iteratively Edit a Task Plan
 
 <expand name="getopt"
     arg1="ase-task-edit"
-    arg2="--plan|-p=(none|OVERWRITE|REFINE|PRESERVE) --dry|-d --next|-n=(none|DONE|IMPLEMENT|PREFLIGHT|REFINE)...">
+    arg2="--plan|-p=(none|OVERWRITE|REFINE|PRESERVE) --dry|-d --next|-n=(none|DONE|GRILL|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
@@ -48,10 +48,11 @@ explicitly requested by this procedure via outputs based on a <template/>!
 <define name="apply-refinement">
 Treat the <instruction/> as a *refinement instruction* for
 the plan, and update <content/> in-place by *applying* the
-requested <instruction/> to the *plan*. When refining the
-plan this way, preserve the overall structure of the plan
-and only modify what the user actually requested. Do *not*
-rewrite unrelated sections of the plan.
+requested <instruction/> to the *plan*.
+
+When refining the plan this way, preserve the overall structure of the
+plan and only modify what the user actually requested. Do *not* rewrite
+unrelated sections of the plan.
 
 Calculate the number of words <words/> of <content/>.
 Set <content-dirty>true</content-dirty>.
@@ -290,9 +291,9 @@ Set <content-dirty>true</content-dirty>.
 
 3.  **Iterative Plan Refinement Loop:**
 
-    *REPEAT* the following steps from 3.1 up to and including 3.4 in a
-    *LOOP* until the user selects `DONE`, `IMPLEMENT`, or `PREFLIGHT`,
-    or declines/cancels in the dialog of step 3.4:
+    *REPEAT* the following steps from 3.1 up to and including 3.4 in
+    a *LOOP* until the user selects `DONE`, `GRILL`, `IMPLEMENT`, or
+    `PREFLIGHT`, or declines/cancels in the dialog of step 3.4:
 
     1.  *Update timestamp*:
         <if condition="<content/> contains '✎ modified:' AND <content-dirty/> is 'true'">
@@ -341,7 +342,7 @@ Set <content-dirty>true</content-dirty>.
             <getopt-option-next/> so subsequent loop iterations or
             downstream skills can consume the tail.
 
-            -   If <head/> matches the regex `^(DONE|IMPLEMENT|PREFLIGHT|REFINE)$`:
+            -   If <head/> matches the regex `^(DONE|GRILL|IMPLEMENT|PREFLIGHT)$`:
                 Honor the pre-selected token.
                 Set <result><head/></result>.
 
@@ -365,9 +366,9 @@ Set <content-dirty>true</content-dirty>.
             <expand name="user-dialog">
                 Next Step: How would you like to proceed with the plan?
                 DONE: Mark plan finalized, exit planning loop.
-                IMPLEMENT: Hand off plan to implementation.
+                GRILL: Hand off plan to grilling.
                 PREFLIGHT: Hand off plan to pre-flighting.
-                REFINE: Further refine plan with instructions.
+                IMPLEMENT: Hand off plan to implementation.
             </expand>
 
         Check the tool <result/> and dispatch accordingly:
@@ -381,7 +382,7 @@ Set <content-dirty>true</content-dirty>.
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
             </template>
 
-        -   If <result/> is `IMPLEMENT`:
+        -   If <result/> is `GRILL`:
 
             *Break* out of the *loop*. Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -389,11 +390,11 @@ Set <content-dirty>true</content-dirty>.
             remaining list tokens to the downstream skill).
             </if>
             Only output the following <template/> and then call the
-            `Skill(skill: "ase:ase-task-implement", args: <args/>)` tool
-            to *apply* the finalized plan.
+            `Skill(skill: "ase:ase-task-grill", args: <args/>)` tool
+            to *grill* the finalized plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to implementation**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to grilling**
             </template>
 
         -   If <result/> is `PREFLIGHT`:
@@ -411,20 +412,19 @@ Set <content-dirty>true</content-dirty>.
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to pre-flight**
             </template>
 
-        -   If <result/> is `REFINE`:
-
-            Ask the user interactively, without a special tool, for the
-            refinement instruction with a single question `**What is
-            your instruction for further refining the plan?**`. Then set
-            <instruction/> to the response of the user.
-
-            <expand name="apply-refinement"/>
+        -   If <result/> is `IMPLEMENT`:
 
-            Finally, only output the following <template/> and then
-            *continue* the *loop* at step **3.1**!
+            *Break* out of the *loop*. Set <args></args> (empty).
+            <if condition="<getopt-option-next/> is not equal `none`">
+            Set <args>--next <getopt-option-next/></args> (forward
+            remaining list tokens to the downstream skill).
+            </if>
+            Only output the following <template/> and then call the
+            `Skill(skill: "ase:ase-task-implement", args: <args/>)` tool
+            to *apply* the finalized plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ⇌ instruction: **<instruction/>**, ▶ status: **plan refined**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to implementation**
             </template>
 
         -   If <result/> matches `OTHER: <text/>`:

package/plugin/skills/ase-task-edit/help.md

@@ -44,16 +44,16 @@ command from outside the agent tool.
 `--next`|`-n` *option*[,...]:
     Automatically answer the user dialog for the next step (at the end
     of this skill). *option* is a single token or a *comma-separated
-    chronological list* of tokens; each iteration of the planning loop
-    consumes the *first* token of the list, and on hand-off (`IMPLEMENT`
-    / `PREFLIGHT`) any remaining tokens are *forwarded* (via `--next`)
-    to the downstream skill so an entire pipeline can be pre-scripted
-    in one shot. Recognized tokens at this skill: `none` (default,
-    interactive answer required), `DONE` (no next step), `IMPLEMENT`
-    (hand-over to `ase-task-implement`), `PREFLIGHT` (hand-over to
-    `ase-task-preflight`), or `REFINE` (refine the plan with subsequent
-    instruction). Example: `--next REFINE,DONE` first refines once,
-    then exits the loop without asking.
+    chronological list* of tokens; each iteration of the planning
+    loop consumes the *first* token of the list, and on hand-off
+    (`IMPLEMENT` / `PREFLIGHT`) any remaining tokens are *forwarded*
+    (via `--next`) to the downstream skill so an entire pipeline can
+    be pre-scripted in one shot. Recognized tokens at this skill:
+    `none` (default, interactive answer required), `DONE` (no next
+    step), `GRILL` (hand-over to `ase-task-grill`), `PREFLIGHT`
+    (hand-over to `ase-task-preflight`), or `IMPLEMENT` (hand-over to
+    `ase-task-implement`). Example: `--next GRILL,DONE` first refines
+    once, then exits the loop without asking.
 
 ##  ARGUMENTS
 

package/plugin/skills/ase-task-grill/SKILL.md

@@ -167,7 +167,7 @@ Procedure
                 <ase-tpl-bullet-normal/> ASPECT <N/>/<n/>: **<aspect-N/>**, ANSWER: **<answer-N/>**
                 </template>
 
-    3.  Finally, update the in <plan/> based on all answers <answer-N/>.
+    3.  Finally, update the plan in <plan/> based on all answers <answer-N/>.
 
     4.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
         `ase` MCP server and use the `text` field of its response for
@@ -217,8 +217,8 @@ Procedure
                 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.
+                IMPLEMENT: Hand off plan to implementation.
             </expand>
 
     2.  Check the tool <result/> and dispatch accordingly:
@@ -246,30 +246,30 @@ Procedure
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to edit**
             </template>
 
-        -   If <result/> is `IMPLEMENT`:
+        -   If <result/> is `PREFLIGHT`:
             Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
             Set <args>--next <getopt-option-next/></args> (forward
             remaining list tokens to the downstream skill).
             </if>
             Only output the following <template/> and then call the
-            `Skill(skill: "ase:ase-task-implement", args: <args/>)` tool
+            `Skill(skill: "ase:ase-task-preflight", args: <args/>)` tool
             to *apply* the plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to implementation**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to pre-flight**
             </template>
 
-        -   If <result/> is `PREFLIGHT`:
+        -   If <result/> is `IMPLEMENT`:
             Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
             Set <args>--next <getopt-option-next/></args> (forward
             remaining list tokens to the downstream skill).
             </if>
             Only output the following <template/> and then call the
-            `Skill(skill: "ase:ase-task-preflight", args: <args/>)` tool
+            `Skill(skill: "ase:ase-task-implement", args: <args/>)` tool
             to *apply* the plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to pre-flight**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to implementation**
             </template>