@rse/ase 0.0.57 → 0.0.59

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

@@ -1,6 +1,6 @@
 ---
 name: ase-task-edit
-argument-hint: "[--help|-h] [--plan|-p <option>] [--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) --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
 ---------
@@ -45,6 +45,47 @@ 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/>!
 
+<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.
+
+Calculate the number of words <words/> of <content/>.
+Set <content-dirty>true</content-dirty>.
+</define>
+
+<define name="generate-plan">
+Create a new plan from scratch and store the result as
+<content/> by closely following the defined plan format
+<format/> and injecting into it all the information from
+the <instruction/> and all decisions you derived from the
+<instruction/>.
+
+If a `CHANGELOG.md` file exists in the project (or in any
+affected sub-package), the plan *MUST* include, as part of
+its `## ※ CHANGES` section, an explicit bullet point
+describing the addition of a corresponding new entry to
+that `CHANGELOG.md` file, aligned with its existing style
+and conventions.
+
+<if condition="<getopt-option-dry/> is equal `true`">
+You *MUST* completely omit the `## ※ VERIFICATION` section
+(including its heading and all of its bullet points) from
+<content/>.
+</if>
+
+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 fresh <timestamp-created/> and <timestamp-modified/>
+information. Then insert the current <ase-task-id/>,
+<timestamp-created/>, and <timestamp-modified/> information
+and calculate the number of words <words/> of <content/>.
+Set <content-dirty>true</content-dirty>.
+</define>
+
 1.  **Determine Task and Instruction:**
 
     1.  Set <instruction><getopt-arguments/></instruction> initially.
@@ -194,19 +235,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         -   If <result/> is `OVERWRITE`:
 
-            Create a new plan from scratch and store the result as
-            <content/> by closely following the defined plan format
-            <format/> and injecting into it all the information from
-            the <instruction/> and all decisions you derived from the
-            <instruction/>.
-
-            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 fresh <timestamp-created/> and <timestamp-modified/>
-            information. Then insert the current <ase-task-id/>,
-            <timestamp-created/>, and <timestamp-modified/> information
-            and calculate the number of words <words/> of <content/>.
-            Set <content-dirty>true</content-dirty>.
+            <expand name="generate-plan"/>
 
             Only output the following <template/> and continue processing:
 
@@ -217,15 +246,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         -   If <result/> is `REFINE`:
 
-            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.
-
-            Calculate the number of words <words/> of <content/>.
-            Set <content-dirty>true</content-dirty>.
+            <expand name="apply-refinement"/>
 
             Only output the following <template/> and continue processing:
 
@@ -239,15 +260,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
             Set <instruction><instruction/> <text/></instruction> (append
             the user's free-text hint to the existing instruction).
 
-            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.
-
-            Calculate the number of words <words/> of <content/>.
-            Set <content-dirty>true</content-dirty>.
+            <expand name="apply-refinement"/>
 
             Only output the following <template/> and continue processing:
 
@@ -265,19 +278,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
         </if>
 
     5.  <if condition="<content/> is empty AND <instruction/> is not empty">
-        Create a new plan from scratch and store the result as
-        <content/> by closely following the defined plan format
-        <format/> and injecting into it all the information from
-        the <instruction/> and all decisions you derived from the
-        <instruction/>.
-
-        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 fresh <timestamp-created/> and <timestamp-modified/>
-        information. Then insert the current <ase-task-id/>,
-        <timestamp-created/>, and <timestamp-modified/> information
-        and calculate the number of words <words/> of <content/>.
-        Set <content-dirty>true</content-dirty>.
+        <expand name="generate-plan"/>
 
         Only output the following <template/> and continue processing:
 
@@ -332,20 +333,31 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     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.
+
+            -   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.
 
-            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.
+            -   else:
+                Only output the following <template/> and then immediately
+                *STOP* processing the entire current skill:
 
-            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.
+                <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.
@@ -371,10 +383,14 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         -   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**
@@ -382,10 +398,14 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         -   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**
@@ -398,13 +418,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
             your instruction for further refining the plan?**`. Then set
             <instruction/> to the response of the user.
 
-            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.
-            Set <content-dirty>true</content-dirty>.
+            <expand name="apply-refinement"/>
 
             Finally, only output the following <template/> and then
             *continue* the *loop* at step **3.1**!
@@ -417,13 +431,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
             Set <instruction><text/></instruction> (replace existing instruction).
 
-            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.
-            Set <content-dirty>true</content-dirty>.
+            <expand name="apply-refinement"/>
 
             Finally, only output the following <template/> and then
             *continue* the *loop* at step **3.1**!

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

@@ -8,7 +8,8 @@
 `ase-task-edit`
     [`--help`|`-h`]
     [`--plan`|`-p` *option*]
-    [`--next`|`-n` *option*]
+    [`--dry`|`-d`]
+    [`--next`|`-n` *option*[,...]]
     [*id* | *id*: *instruction* | *instruction*]
 
 ##  DESCRIPTION
@@ -32,13 +33,27 @@ command from outside the agent tool.
     *instruction*), or `PRESERVE` (preserve the existing plan by
     ignoring *instruction* and stopping skill processing).
 
-`--next`|`-n` *option*:
+`--dry`|`-d`:
+    Generate any *new* plan *without* the `※ VERIFICATION` section.
+    Applies only to freshly generated plans, not to existing plans
+    loaded from disk. When `ase-task-implement` later applies such
+    a plan, it strictly skips the entire verification phase (no
+    build, tests, linter, type-checker, or program execution) once
+    the source files have been modified.
+
+`--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
 

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

@@ -0,0 +1,275 @@
+---
+name: ase-task-grill
+argument-hint: "[--help|-h] [--next|-n <option>[,...]] [<id>]"
+description: >
+    Interview the user relentlessly about the task plan until reaching a
+    shared understanding, resolving each branch of the question decision
+    tree. Use when the user wants to stress-test a plan, get grilled on
+    their plan, or mentions "grill me" or "grill plan".
+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-grill">
+Iteratively Grill a Task Plan
+</skill>
+
+<expand name="getopt"
+    arg1="ase-task-grill"
+    arg2="--next|-n=(none|DONE|EDIT)...">
+    $ARGUMENTS
+</expand>
+
+<objective>
+Interview the user relentlessly about every essential aspect of the
+task plan until reaching a shared understanding.
+</objective>
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-format-plan.md
+
+Procedure
+---------
+
+1.  **Determine Task:**
+
+    1.  Set <id>$ARGUMENTS</id> 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="
+                <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
+            ">
+            Set <ase-task-id><id/></ase-task-id> (set task id) and
+            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="<id/> 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-grill**, ▶ **ERROR**: expected single `[<id>]` argument
+            </template>
+            </if>
+
+2.  **Determine Task Plan:**
+
+    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:`:
+            Output the following <template/> and then immediately *STOP*
+            processing the entire current skill:
+
+            <template>
+            ⧉ **ASE**: ☻ skill: **ase-task-grill**, ▶ **<text/>**
+            </template>
+
+        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
+            Set <plan><text/></plan> (set plan to text).
+            Calculate the number of words <words/> of <plan/>.
+
+        Output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan loaded**
+        </template>
+
+    2.  <if condition="<plan/> 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.  **Iterate Over Task Plan Aspects:**
+
+    Interactively interview the user *relentlessly* about every
+    *essential aspect* of the task plan in <plan/> *until* reaching a
+    shared understanding and no decisions/questions are left open.
+
+    For this process, determine the <n/> essential aspects <aspect-N/>
+    (a one or two word long short identifier like `Foo` or `Bar-Baz`)
+    and the corresponding decision/question <question-N/> where a shared
+    understanding is required upon.
+
+    Honor also the following checks for identifying the problematic
+    aspects:
+
+    -   **Fuzzy Language**:
+        When the user uses vague or overloaded terms instead of a precise
+        or canonical terms.
+
+    -   **Conflicting Terminology**:
+        When the user uses a term that conflicts with the existing
+        terminology in the code base.
+
+    -   **Conflicting Code**:
+        When the user states how something works, check whether the
+        current code state really agrees.
+
+    -   **Non-Concrete Scenarios**:
+        When domain relationships are being discussed, stress-test them
+        with specific scenarios. Invent scenarios that probe edge cases
+        and force the user to be precise about the boundaries between
+        concepts.
+
+    Then create a decisions/questions tree for them. Walk down each
+    branch of this decision tree, resolving dependencies between
+    decisions one-by-one. Ask the questions <question-N/> and determine
+    corresponding answer <answer-N/>, one at a time.
+
+    1.  For each question <question-N/> in the iteration circle <N/>:
+
+        1.  Output the following <template/>:
+
+            <template>
+            &#x1F7E0; ASPECT <N/>/<n/>: **<aspect-N/>**, QUESTION: **<question-N/>**
+            </template>
+
+        2.  Determine the answer alternatives:
+
+            1.  Check the <plan/> for the answer <answer-N-1/>.
+
+            2.  Check the code base and your world knowledge and
+                use this information to find *up to three* grounded
+                alternative answers <answer-N-K/> (K={2,3,4}).
+
+            3.  Use an interactive user dialog
+                with header <aspect-N/> and question <question-N/>, and
+                let the user select the <answer-N/> out of <answer-N-K/>
+                (K={1..4}). In this dialog, mark the <answer-N-1/> by
+                appending ` ⚝ **CURRENT PLAN** ⚝` to its option name (not the
+                description).
+
+            4.  Output the following <template/>:
+
+                <template>
+                &#x1F535; ASPECT <N/>/<n/>: **<aspect-N/>**, ANSWER: **<answer-N/>**
+                </template>
+
+    3.  Finally, update the 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
+        <timestamp-modified/> information. Then insert the current
+        <ase-task-id/>, previous <timestamp-created/>, and refreshed
+        <timestamp-modified/> information and calculate the number of
+        words <words/> of <plan/>.
+
+    5.  Call the `ase_task_save(id: "<ase-task-id/>",
+        text: "<plan/>")` of the `ase` MCP server to save the updated
+        task plan content. Do not output anything related to this MCP
+        call.
+
+    6.  Only output the following <template/> and continue processing:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated**
+        </template>
+
+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-grill**, ▶ 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 updated -- 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 updated plan. Immediately stop processing the current
+            skill once the `Skill` tool was used.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- 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 updated -- 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 updated -- hand-off to pre-flight**
+            </template>

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

@@ -0,0 +1,79 @@
+
+##  NAME
+
+`ase-task-grill` - Iteratively Grill a Task Plan
+
+##  SYNOPSIS
+
+`ase-task-grill`
+    [`--help`|`-h`]
+    [`--next`|`-n` *option*[,...]]
+    [*id*]
+
+##  DESCRIPTION
+
+The `ase-task-grill` skill *relentlessly interviews* the user about
+every *essential aspect* of an existing *task plan* until a *shared
+understanding* is reached and no decisions or questions are left open.
+
+The skill identifies the essential aspects of the plan, builds a
+decision tree of the open questions, and walks down each branch
+one-by-one. For each aspect it presents up to four *grounded*
+alternative answers (the current plan plus alternatives derived from
+the code base and world knowledge), marks the current-plan choice, and
+lets the user pick via an interactive dialog. It honors checks for
+*fuzzy language*, *conflicting terminology*, *conflicting code*, and
+*non-concrete scenarios*. Once all aspects are resolved, the plan is
+updated and persisted, and the user is offered a hand-off to editing,
+implementation, or preflight.
+
+The task plan is stored in `.ase/tasks/`*id*`/plan.md` files of the
+project and can be alternatively edited with the "`ase task edit` *id*"
+command from outside the agent tool.
+
+##  OPTIONS
+
+`--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; the *first* token is consumed by
+    this skill and any remaining tokens are *forwarded* (via `--next`)
+    to the downstream skill on hand-off 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),
+    `EDIT` (hand-over to `ase-task-edit`), `IMPLEMENT` (hand-over to
+    `ase-task-implement`), or `PREFLIGHT` (hand-over to
+    `ase-task-preflight`).
+
+##  ARGUMENTS
+
+*id*:
+    Grill the task with the unique identifier *id* (default: `default`).
+    The skill accepts *only* an optional *id* argument and never a
+    free-text instruction.
+
+##  EXAMPLES
+
+Grill the current task plan:
+
+```text
+❯ /ase-task-grill
+```
+
+Grill the task plan under id `hello`:
+
+```text
+❯ /ase-task-grill hello
+```
+
+Grill the current task plan and then hand off to editing:
+
+```text
+❯ /ase-task-grill --next EDIT
+```
+
+##  SEE ALSO
+
+`ase-task-edit`, `ase-task-reboot`, `ase-task-preflight`,
+`ase-task-implement`, `ase-task-view`, `ase-task-list`,
+`ase-task-rename`, `ase-task-delete`.

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

@@ -7,7 +7,7 @@ description: >
     or wants to know what the current task is.
 user-invocable: true
 disable-model-invocation: false
-effort: low
+effort: high
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md