@rse/ase 0.0.58 → 0.0.60

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

@@ -9,7 +9,8 @@
     [`--help`|`-h`]
     [`--auto`|`-a`]
     [`--dry`|`-d`]
-    [`--next`|`-n` *option*]
+    [`--quick`|`-Q`]
+    [`--next`|`-n` *option*[,...]]
     [*task-id*:] *request*
 
 ##  DESCRIPTION
@@ -39,13 +40,28 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     type-checker, or program execution) once the source files have
     been modified.
 
-`--next`|`-n` *option*:
-    Automatically choose the next step after composing the plan,
-    where *option* is either `none` (default, hand-off to
-    `ase-task-edit` interactively), `DONE` (stop), `EDIT` (hand off
-    to `ase-task-edit`), `PREFLIGHT` (hand off to
-    `ase-task-preflight`), or `IMPLEMENT` (hand off to
-    `ase-task-implement`).
+`--quick`|`-Q`:
+    Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
+    the recommended refactoring approach, compose the plan *without* the
+    `※ VERIFICATION` section, immediately hand off to `ase-task-implement`,
+    and finally `ase-task-delete` the now-consumed plan. This gives a
+    single, fast *one-shot* refactoring mode.
+
+`--next`|`-n` *option*[,...]:
+    Automatically choose the next step after composing the plan.
+    *option* is a single token or a *comma-separated chronological
+    list* of tokens; an `IMPLEMENT` or `PREFLIGHT` head token is
+    consumed by this skill (bypassing `ase-task-edit`), and any
+    remaining tokens are *forwarded* (via `--next`) to the downstream
+    skill. For all other head tokens, the *entire* list is forwarded
+    to `ase-task-edit`, which consumes its head itself. This lets an
+    entire pipeline be pre-scripted in one shot. Recognized tokens at
+    this skill: `none` (default, hand-off to `ase-task-edit`
+    interactively), `DONE` (stop), `EDIT` (hand off to
+    `ase-task-edit`), `PREFLIGHT` (hand off to `ase-task-preflight`),
+    or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
+    `--next PREFLIGHT,IMPLEMENT,DONE` refactors, preflights, implements,
+    and exits without further dialog.
 
 ##  ARGUMENTS
 

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

@@ -1,12 +1,12 @@
 ---
 name: ase-code-resolve
-argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--next|-n <option>] [<task-id>:] <problem>"
+argument-hint: "[--help|-h] [--auto|-a] [--dry|-d] [--quick|-Q] [--next|-n <option>[,...]] [<task-id>:] <problem>"
 description: >
     Resolve Problem:
     Use when user wants a bug fixed or problem resolved.
 user-invocable: true
 disable-model-invocation: false
-effort: high
+effort: xhigh
 allowed-tools:
     - "Skill"
     - "Agent"
@@ -23,16 +23,22 @@ Resolve Problem
 
 <expand name="getopt"
     arg1="ase-code-resolve"
-    arg2="--auto|-a --dry|-d --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)">
+    arg2="--auto|-a --dry|-d --quick|-Q --next|-n=(none|DONE|EDIT|PREFLIGHT|IMPLEMENT)...">
     $ARGUMENTS
 </expand>
 
+<if condition="<getopt-option-quick/> is equal `true`">
+The `--quick`/`-Q` flag is a *shorthand alias*: set <getopt-option-auto/>
+to `true`, <getopt-option-dry/> to `true`, and <getopt-option-next/> to
+`IMPLEMENT,DELETE`. Do not output anything.
+</if>
+
 <objective>
 *Resolve* the following problem:
 <problem><getopt-arguments/></problem>
 </objective>
 
-@${CLAUDE_SKILL_DIR}/../../meta/ase-plan.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
 
 Procedure
 ---------
@@ -210,7 +216,10 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     You *MUST* perform the following sub-steps *internally* and *without
     any output* until and including the recommendation decision. Only
-    sub-step 4 below is allowed to produce output.
+    sub-steps 4-6 below are allowed to produce output, and only if
+    <getopt-option-auto/> is equal `false`. If <getopt-option-auto/> is
+    equal `true`, *skip* the reporting sub-steps 4-6 entirely (perform
+    no output at all) to speed up processing.
 
     1.  *Propose* corresponding *resolution approach*, including optionally,
         some *alternative* resolution approaches. Do *not* output anything
@@ -340,23 +349,42 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
 
     6.  Directly pass-through control to the next skill:
 
-        1.  <if condition="<getopt-option-next/> is equal `IMPLEMENT`">
-            Call the tool `Skill(skill: "ase:ase-task-implement")` to
-            *implement* the freshly composed plan, bypassing `ase-task-edit`.
+        Treat <getopt-option-next/> as a comma-separated chronological
+        list of pre-selected next-step tokens. *Peek* the *first* token
+        as <head/> (or `none` if the list is `none`/empty).
+
+        1.  <if condition="<head/> is equal `IMPLEMENT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). 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>
+            Call the tool `Skill(skill: "ase:ase-task-implement", args: <args/>)`
+            to *implement* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
-        2.  <if condition="<getopt-option-next/> is equal `PREFLIGHT`">
-            Call the tool `Skill(skill: "ase:ase-task-preflight")` to
-            *preflight* the freshly composed plan, bypassing `ase-task-edit`.
+        2.  <if condition="<head/> is equal `PREFLIGHT`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). 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>
+            Call the tool `Skill(skill: "ase:ase-task-preflight", args: <args/>)`
+            to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </if>
 
         3.  <if condition="
-                <getopt-option-next/> is not equal `IMPLEMENT` AND
-                <getopt-option-next/> is not equal `PREFLIGHT`
+                <head/> is not equal `IMPLEMENT` AND
+                <head/> is not equal `PREFLIGHT`
             ">
-            Set <args></args> (set args to empty).
+            Forward the *entire* (unshifted) list to `ase-task-edit`, which
+            will consume its head itself. Set <args></args> (empty).
             <if condition="<getopt-option-next/> is not equal `none`">
-            Set <args><args/> --next <getopt-option-next/></args> (append to args).
+            Set <args>--next <getopt-option-next/></args> (append to args).
             </if>
             Then call the tool `Skill(skill: "ase:ase-task-edit", args: <args/>)`.
             </if>

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

@@ -9,7 +9,8 @@
     [`--help`|`-h`]
     [`--auto`|`-a`]
     [`--dry`|`-d`]
-    [`--next`|`-n` *option*]
+    [`--quick`|`-Q`]
+    [`--next`|`-n` *option*[,...]]
     [*task-id*:] *problem*
 
 ##  DESCRIPTION
@@ -44,13 +45,28 @@ plan via `ase_task_save` and then hands off to `ase-task-edit`,
     type-checker, or program execution) once the source files have
     been modified.
 
-`--next`|`-n` *option*:
-    Automatically choose the next step after composing the plan,
-    where *option* is either `none` (default, hand-off to
-    `ase-task-edit` interactively), `DONE` (stop), `EDIT` (hand off
-    to `ase-task-edit`), `PREFLIGHT` (hand off to
-    `ase-task-preflight`), or `IMPLEMENT` (hand off to
-    `ase-task-implement`).
+`--quick`|`-Q`:
+    Shorthand alias for `-a -d -n IMPLEMENT,DELETE`: automatically pick
+    the recommended resolution approach, compose the plan *without* the
+    `※ VERIFICATION` section, immediately hand off to `ase-task-implement`,
+    and finally `ase-task-delete` the now-consumed plan. This gives a
+    single, fast *one-shot* resolution mode.
+
+`--next`|`-n` *option*[,...]:
+    Automatically choose the next step after composing the plan.
+    *option* is a single token or a *comma-separated chronological
+    list* of tokens; an `IMPLEMENT` or `PREFLIGHT` head token is
+    consumed by this skill (bypassing `ase-task-edit`), and any
+    remaining tokens are *forwarded* (via `--next`) to the downstream
+    skill. For all other head tokens, the *entire* list is forwarded
+    to `ase-task-edit`, which consumes its head itself. This lets an
+    entire pipeline be pre-scripted in one shot. Recognized tokens at
+    this skill: `none` (default, hand-off to `ase-task-edit`
+    interactively), `DONE` (stop), `EDIT` (hand off to
+    `ase-task-edit`), `PREFLIGHT` (hand off to `ase-task-preflight`),
+    or `IMPLEMENT` (hand off to `ase-task-implement`). Example:
+    `--next IMPLEMENT,DONE` resolves the problem, implements it, and
+    exits without further dialog.
 
 ##  ARGUMENTS
 

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

@@ -5,7 +5,7 @@ description: >
     Update changes entries in CHANGELOG.md files
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 allowed-tools:
     - "Bash(git log *)"
     - "Bash(git diff *)"

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

@@ -7,7 +7,7 @@ description: >
     DeepSeek or xAI Grok should be queried with a single chat message.
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: medium
 allowed-tools:
     - "Agent"
 ---

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

@@ -0,0 +1,152 @@
+---
+name: ase-meta-diaboli
+argument-hint: "[--help|-h] <thesis>"
+description: >
+    Challenge a thesis by playing "Devil’s Advocate" (latin: "Advocatus
+    Diaboli"). Use when the user wants a thesis or statement
+    relentlessly challenged or criticised.
+user-invocable: true
+disable-model-invocation: false
+effort: xhigh
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+
+<skill name="ase-meta-diaboli">
+    Play "Devil's Advocate"
+</skill>
+
+<objective>
+    Play "Devil’s Advocate" (latin: "Advocatus Diaboli") by relentlessly
+    challenging or criticising the thesis: <thesis>$ARGUMENTS</thesis>
+</objective>
+
+1.  **Repeat Thesis**:
+
+    Output the thesis with the following <template/>:
+
+    <template>
+    &#x26AA; **THESIS**: <thesis/>
+    </template>
+
+2.  **Determine Anti-Thesis**:
+
+    Reason on the thesis in <thesis/> by playing *Devil’s Advocate*
+    (latin: *Advocatus Diaboli*) by relentlessly challenging or
+    criticising it with the help of the following tenets:
+
+    -   **Steelmanning**:
+        Attack the strongest ("steelman") interpretation of the
+        <thesis/>, not the weakest ("strawman"), because defeating a
+        strawman proves nothing.
+
+    -   **Stress-Testing Fundamentals**:
+        Identify weaknesses already in the fundamental ideas behind the
+        thesis, because if the foundation is already cracked, no amount
+        of polish on the surface can save what is built on top of it.
+
+    -   **Target Claims, Not Person**:
+        Critique the thesis, the assumption, the evidence — never the
+        proponent's competence or motives, because the moment it gets
+        personal, the inquiry dies.
+
+    -   **Make the Implicit Explicit**:
+        Surface the unstated assumptions the thesis silently depends on,
+        because most weak arguments hide in premises nobody bothered to say
+        out loud.
+
+    -   **Demand Evidence Proportional to Claim**:
+        Ask "How do we know this?" and "What would it take to be true?",
+        because extraordinary claims need extraordinary support and
+        comfortable consensus needs scrutiny most of all.
+
+    -   **Seek the Disconfirming Case**:
+        Actively hunt for the counterexample, the edge case, the scenario
+        where the position fails, because one solid counterexample outweighs
+        ten confirmations.
+
+    -   **Risk Identification**:
+        Focus on potential problems in the thesis with the highest
+        potential risk only, because low-risk problems are not worth the
+        explicit discussion.
+
+    -   **Push the Logic to its Conclusion**:
+        Ask "If we accept this, then what?" and apply "Reduction to
+        Absurdity" (latin: "Reductio Ad Absurdum"), because this disproves
+        the thesis by showing that accepting it leads to a logically
+        absurd, contradictory, or impossible conclusion.
+
+    -   **Expose Hidden Costs and Trade-Offs**:
+        Name the opportunity cost, the maintenance burden, the failure mode
+        nobody priced in, because every choice in the thesis forecloses
+        alternatives.
+
+    -   **Stay Falsifiable and Concrete**:
+        Frame objections so they can be answered or dismissed with facts,
+        because vague unease ("I just don't like it") is just noise.
+
+    -   **Argue in Good Faith**:
+        Make clear you're just stress-testing the thesis, not
+        obstructing, because the goal of the objective is a better final
+        decision, not winning.
+
+    -   **Know When to Yield**:
+        Conceding when the argument holds is what makes the challenge
+        credible, because a Devil's Advocate who can never be satisfied is
+        just a contrarian.
+
+    -   **Pre-Mortem Thinking**:
+        Imagine failure scenarios of the thesis, because better to
+        prevent them in advance than having to resolve them later.
+
+    For each Anti-Thesis or Counter-Argument rank it on a Likert scale
+    of 0 (weak) to 10 (strong). Repeat the process of finding more
+    Anti-Theses or Counter-Arguments until you EITHER have found at
+    least 10 Anti-Theses or Counter-Arguments with at least a rank
+    of 7 OR you have already checked a total of 50 Anti-Theses or
+    Counter-Arguments.
+
+    Then, for the top-10 highest-ranked Anti-Theses or
+    Counter-Arguments, sort them by their rank from highest to lowest,
+    store each in <antithesis-N/> with the format `**<aspect-N/>**
+    (rank: <rank-N/>/10): <statement-N/>` (where <aspect-N/> is a short
+    1-3 word summary of <statement-N/>, <rank-N/> is the determined
+    rank on the Likert scale, and <statement-N/> is a single-sentence
+    statement of not more than 40 words), and then output the following
+    <template/>:
+
+    <template>
+    &#x1F7E0; **ANTITHESIS**: <antithesis-N/>
+    </template>
+
+3.  **Dialectical Reasoning**:
+
+    Following the Hegelian dialectics of...
+
+        *Thesis* + *Antithesis* → *Synthesis*
+
+    ...with...
+
+    -   *Thesis*: the initial statement, claim, or position. It is asserted
+        as true, but on its own it is one-sided: it captures part of the truth
+        while ignoring its own limits, gaps, or internal tensions.
+
+    -   *Antithesis*: the opposing force. It is the contradiction,
+        objection, or counter-position that the thesis provokes — precisely
+        the role a Devil's Advocate played. The antithesis exposes what the
+        thesis omitted or got wrong.
+
+    -   *Synthesis*: the resolution. Not a mushy "average" of the two, and
+        not the victory of one over the other, but a higher position that
+        preserves what was true in both while discarding what was false. The
+        synthesis transcends the conflict by reframing it.
+
+    ...finally derive a strong single-sentence (not more than 40 words)
+    synthesis of the <thesis/> and all found <antithesis-N/>, store it
+    in <synthesis/>, and then finally output the following <template/>:
+
+    <template>
+    &#x1F535; **SYNTHESIS**: <synthesis/>
+    </template>
+

package/plugin/skills/ase-meta-diaboli/help.md

@@ -0,0 +1,60 @@
+
+##  NAME
+
+`ase-meta-diaboli` - Play "Devil's Advocate" (latin: "Advocatus Diaboli")
+
+##  SYNOPSIS
+
+`ase-meta-diaboli`
+    [`--help`|`-h`]
+    *thesis*
+
+##  DESCRIPTION
+
+The `ase-meta-diaboli` skill plays *Devil's Advocate* (latin:
+*Advocatus Diaboli*) by relentlessly challenging or criticising a
+supplied *thesis*. It applies a disciplined set of critical-thinking
+tenets — steelmanning, stress-testing fundamentals, surfacing implicit
+assumptions, demanding proportional evidence, seeking disconfirming
+cases, *Reductio Ad Absurdum*, exposing hidden costs, and pre-mortem
+thinking — while targeting the claim rather than its proponent and
+yielding where the argument genuinely holds.
+
+The skill iterates until it has found at least ten anti-theses
+(counter-arguments) each ranked at least 7 on a 0 (weak) to 10
+(strong) Likert scale, reports the top ten sorted from strongest to
+weakest, and finally applies *Hegelian dialectics* (*Thesis* +
+*Antithesis* → *Synthesis*) to derive a single-sentence *SYNTHESIS*
+that preserves what is true in both the thesis and its antitheses
+while discarding what is false.
+
+The intent is constructive: stress-testing the thesis in good faith to
+arrive at a better final decision, not obstructing or merely being
+contrarian.
+
+##  ARGUMENTS
+
+*thesis*:
+    The statement, claim, or position to be relentlessly challenged.
+    It may be technical, factual, or opinion-based; the skill attacks
+    its strongest ("steelman") interpretation.
+
+##  EXAMPLES
+
+Challenge a technology-choice claim:
+
+```text
+❯ /ase-meta-diaboli HAPI is the best REST framework
+```
+
+Stress-test a design decision:
+
+```text
+❯ /ase-meta-diaboli We should rewrite the service in Rust.
+```
+
+##  SEE ALSO
+
+`ase-meta-why`, `ase-meta-evaluate`, `ase-meta-quorum`,
+`ase-meta-persona`.
+

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

@@ -10,7 +10,7 @@ description: >
     Use when user says "persona <persona>" or "be <persona>".
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md

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

@@ -5,7 +5,7 @@ description: >
     Query Multiple AIs for Quorum Answer.
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 allowed-tools:
     - "Agent"
     - "TaskCreate"

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

@@ -6,7 +6,7 @@ description: >
     Prefer this skill before using Perplexity, Brave and WebSearch.
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: medium
 allowed-tools:
     - "mcp__search-perplexity__perplexity_search"
     - "mcp__search-brave__brave_web_search"

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

@@ -5,7 +5,7 @@ description: >
     Five-Whys Root-Cause Analysis.
 user-invocable: true
 disable-model-invocation: false
-effort: medium
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@@ -27,7 +27,7 @@ addressing surface-level symptoms.
 </objective>
 
 <flow>
-1.  <step id="STEP 1: PROBLEM">
+1.  <step id="STEP 1: Determine Problem">
     State the problem statement.
 
     <template>
@@ -35,7 +35,7 @@ addressing surface-level symptoms.
     </template>
     </step>
 
-2.  <step id="STEP 2: ROOT-CAUSE ANALYSIS">
+2.  <step id="STEP 2: Root-Cause Analysis">
     Find the root-cause of <problem/> by following the following iteration cycle.
     Start with a <question/> set equal to the <problem/>.
 
@@ -55,7 +55,7 @@ addressing surface-level symptoms.
     </for>
     </step>
 
-3.  <step id="STEP 3: SOLUTION">
+3.  <step id="STEP 3: Report Solution">
     Validate the root-cause by working backwards the causality chain.
     Propose a solution that addresses and solves the root-cause.
     For the proposed solution, optionally directly propose corresponding source code changes.

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

@@ -7,7 +7,7 @@ description: >
     "task", "plan", "spec", or "specification".
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md

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

@@ -1,6 +1,6 @@
 ---
 name: ase-task-edit
-argument-hint: "[--help|-h] [--plan|-p <option>] [--dry|-d] [--next|-n <option>] [<id> | <id>: <instruction> | <instruction>]"
+argument-hint: "[--help|-h] [--plan|-p <option>] [--dry|-d] [--next|-n <option>[,...]] [<id> | <id>: <instruction> | <instruction>]"
 description: >
     Iteratively edit and refine a named plan for a task through a
     conversational loop. Each round, the current plan is shown and the
@@ -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|IMPLEMENT|PREFLIGHT|REFINE)...">
     $ARGUMENTS
 </expand>
 
@@ -34,7 +34,7 @@ continued refinement, finalization, or hand-off to implementation or
 preflight.
 </objective>
 
-@${CLAUDE_SKILL_DIR}/../../meta/ase-plan.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
 
 Procedure
 ---------
@@ -333,20 +333,31 @@ Set <content-dirty>true</content-dirty>.
 
     4.  *Determine next step*:
 
-        -   If <getopt-option-next/> matches the regex `^(DONE|IMPLEMENT|PREFLIGHT|REFINE)$`:
-            Honor the pre-selection what to do as the next step.
-            Set <result><getopt-option-next/></result>.
+        -   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 subsequent loop iterations or
+            downstream skills can consume the tail.
 
-            Then *clear* <getopt-option-next/> by setting
-            <getopt-option-next>none</getopt-option-next> so that
-            subsequent loop iterations fall back to the interactive
-            dialog.
+            -   If <head/> matches the regex `^(DONE|IMPLEMENT|PREFLIGHT|REFINE)$`:
+                Honor the pre-selected token.
+                Set <result><head/></result>.
 
-            Set <instruction></instruction> (clear the instruction, as
-            any instruction carried in via the arguments was already
-            applied to the plan in step 2 before this loop), so that a
-            pre-selected `REFINE` correctly asks the user for a *fresh*
-            refinement instruction below.
+                Set <instruction></instruction> (clear the instruction, as
+                any instruction carried in via the arguments was already
+                applied to the plan in step 2 before this loop), so that a
+                pre-selected `REFINE` correctly asks the user for a *fresh*
+                refinement instruction below.
+
+            -   else:
+                Only output the following <template/> and then immediately
+                *STOP* processing the entire current skill:
+
+                <template>
+                ⧉ **ASE**: ☻ skill: **ase-task-edit**, ▶ 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.
@@ -372,10 +383,14 @@ Set <content-dirty>true</content-dirty>.
 
         -   If <result/> is `IMPLEMENT`:
 
-            *Break* out of the *loop*, only output the following
-            <template/> and then call the `Skill(skill:
-            "ase:ase-task-implement")` tool to *apply* the finalized
-            plan.
+            *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/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to implementation**
@@ -383,10 +398,14 @@ Set <content-dirty>true</content-dirty>.
 
         -   If <result/> is `PREFLIGHT`:
 
-            *Break* out of the *loop*, only output the following
-            <template/> and then call the `Skill(skill:
-            "ase:ase-task-preflight")` tool to *apply* the finalized
-            plan.
+            *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-preflight", args: <args/>)` tool
+            to *apply* the finalized plan.
 
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- hand-off to pre-flight**

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

@@ -9,7 +9,7 @@
     [`--help`|`-h`]
     [`--plan`|`-p` *option*]
     [`--dry`|`-d`]
-    [`--next`|`-n` *option*]
+    [`--next`|`-n` *option*[,...]]
     [*id* | *id*: *instruction* | *instruction*]
 
 ##  DESCRIPTION
@@ -41,13 +41,19 @@ command from outside the agent tool.
     build, tests, linter, type-checker, or program execution) once
     the source files have been modified.
 
-`--next`|`-n` *option*:
+`--next`|`-n` *option*[,...]:
     Automatically answer the user dialog for the next step (at the end
-    of this skill) with *option*, which can be either `none` (default,
+    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).
+    instruction). Example: `--next REFINE,DONE` first refines once,
+    then exits the loop without asking.
 
 ##  ARGUMENTS