@rse/ase 0.9.54 → 0.9.56

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

@@ -21,7 +21,7 @@ Condense a Task Plan
 
 <expand name="getopt"
     arg1="ase-task-condense"
-    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)...">
+    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|PREFLIGHT)... --int-reuse-task">
     $ARGUMENTS
 </expand>
 
@@ -48,68 +48,31 @@ Set <args></args> (set args to empty).
 
 1.  **Determine Task:**
 
-    1.  Set <id><getopt-arguments/></id> initially.
+    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:
 
-        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.  <elseif 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-condense**, ▶ ERROR: expected single `[<id>]` argument
-            </template>
-            </elseif>
+        <expand name="task-react-id" arg1="ase-task-condense"></expand>
 
 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.
+    1.  Determine the current task plan content:
 
-        -   If <text/> starts with `ERROR:` or `WARNING:`:
-            Silently ignore the MCP error.
-            Set <task-content></task-content> (set task content to empty).
-            Set <words/> to "0".
-
-        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
-            Set <task-content><text/></task-content> (set task content to text).
-            Calculate the number of words <words/> of <task-content/>.
+        <expand name="task-load-content"></expand>
 
         Set <words-before><words/></words-before> (remember the loaded
         word count for the strictly-smaller check in step 3).
 
-        <if condition="<task-content/> contains '⎈   Created:  <text/>'">
+        <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>
 
-        Only output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan loaded**
-        </template>
-
     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
@@ -125,10 +88,11 @@ Set <args></args> (set args to empty).
         and unchanged*. Honor the following ruleset *strictly*:
 
         1.  *Preserve-exactly (never alter)*: the plan <format/>
-            structure (the headings `#`/`##`, all three `##  CONTEXT`,
-            `##  CHANGES`, and `##  VERIFICATION` sections, the
-            `Created:`/`Modified:` lines, and
-            the `- **<aspect/>**:` bullet labels), all *code spans* and
+            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.
@@ -146,33 +110,14 @@ Set <args></args> (set args to empty).
                 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
+                restated) and *drop* pure duplication -- but *only* when
                 truly redundant; *never* lose a distinct aspect.
 
-        3.  *Normalize the rendering artifacts*: the loaded
-            <task-content/> is the *rendering-prepared* variant of the
-            plan, whose artifacts *MUST NOT* be persisted back. Restore
-            the *authoring form* of the plan <format/> before saving:
-
-            -   A bullet point rendered as `◯   ` is written back as
-                `-   ` -- the condensed <task-content/> *MUST NOT*
-                contain a single `◯` marker.
-
-            -   An inline code span which the rendering split across two
-                physical lines into two spans (`` `<head/>` `` at a line
-                end and `` `<tail/>` `` at the next line start) is
-                written back as the *one* original span
-                `` `<head/> <tail/>` ``, and the line is then broken
-                *before* its opening backtick.
-
-            This normalization is *not* a semantic change and hence
-            *never* violates the preserve-exactly rule 1.
-
-        4.  *Persona override*: this condense ruleset *always wins* for
+        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.
 
-        5.  *Hard guardrail - semantics preserved EXACTLY*: condensing
+        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
@@ -187,8 +132,10 @@ Set <args></args> (set args to empty).
             </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/>:
+            Do *not* save and do *not* bump the timestamp. Set
+            <words><words-before/></words> (report the word count of the
+            *unchanged* stored plan, not of the discarded condensed one).
+            Only output the following <template/>:
 
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan already condensed**

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

@@ -30,7 +30,7 @@ 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*.
+`Modified:` frontmatter 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

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

@@ -66,7 +66,7 @@ Procedure
             ⧉ **ASE**: ◉ task: **<id/>**, ▶ status: **<text/>**
             </template>
 
-        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
+        -   If <text/> does NOT start with `ERROR:` and NOT with `WARNING:`:
             Set <deleted>true</deleted> and only output the following
             <template/>:
 

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

@@ -204,6 +204,11 @@ Procedure
             following the plan <format/>, where:
 
             -   the <task-id/> is <part-id/>,
+            -   the <task-status/> is `DRAFTED` and the <task-properties/>
+                is `none`, as every part is a *newly created* plan,
+            -   the <task-kind/> is taken over from the epic *verbatim*,
+                or inferred from the part content if the epic carries no
+                `Kind:` key,
             -   the <title/> is derived from the part's <scope/>,
             -   the `##  CONTEXT` section carries a part-local
                 <summary-what/> and <summary-why/>, derived from the
@@ -225,24 +230,6 @@ Procedure
             *MUST* still reproduce the original bullet point *completely*
             and *without* duplication.
 
-            The loaded <task-content/> is the *rendering-prepared*
-            variant of the epic, so it carries artifacts which *MUST NOT*
-            leak into the persisted <part-content/>. While copying, you
-            *MUST* *normalize* every taken-over bullet point back into
-            the authoring form of the plan <format/>:
-
-            -   *Restore the bullet markers*: a bullet point rendered as
-                `◯   ` is written back as `-   ` -- <part-content/>
-                *MUST NOT* contain a single `◯` marker.
-
-            -   *Re-join split code spans*: an inline code span which the
-                rendering split across two physical lines into two spans
-                (`` `<head/>` `` at a line end and `` `<tail/>` `` at the
-                next line start) is written back as the *one* original
-                span `` `<head/> <tail/>` ``, and the line is then broken
-                *before* its opening backtick, per the line-breaking
-                rules of the plan <format/>.
-
             <if condition="<task-content/> does NOT contain a `##  VERIFICATION` section heading">
             The epic itself deliberately *omits* the `##  VERIFICATION`
             section, so you *MUST* omit this section (including its

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

@@ -177,22 +177,31 @@ Set <args></args> (set args to empty).
 
         <if condition="
             <getopt-option-int-reuse-task/> is equal `true`
-            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
+            *and* an `ase_task_save(id: '<ase-task-id/>', ...)` tool call
             exists earlier in the current session
         ">
-            Set <text/> to the `text` *output* field of the most recent
+            Set <text/> to the `text` *argument* of the most recent
             `ase_task_save(id: '<ase-task-id/>', ...)` tool call -- this
-            is the rendering-prepared plan content and *MUST NOT* be
-            confused with the `text` *argument* passed into that call --
-            *without* calling `ase_task_load` again. Set <status>plan
-            reused</status>. Do not output anything.
+            is the *authoring form* of the plan and *MUST NOT* be
+            confused with the `text` *output* field of that call --
+            *without* calling `ase_task_load` again. Set
+            <task-render></task-render> (set the rendering-prepared plan
+            to empty, as it is re-derived in step 3.2 or 3.3). Set
+            <status>plan reused</status>. Do not output anything.
         </if>
         <else>
-            Call the `ase_task_load(id: "<ase-task-id/>")` tool of the
-            `ase` MCP server to load any existing plan content and set
-            <text/> to the `text` output field of this `ase_task_load`
-            tool call. Do not output anything related to this MCP tool
-            call. Set <status>plan loaded</status>.
+            Call the `ase_task_load(id: "<ase-task-id/>", variant:
+            "both")` tool of the `ase` MCP server to load any existing
+            plan content in *both* of its forms. From the `text` output
+            field of this `ase_task_load` tool call, set <text/> to the
+            content enclosed in the `<task-plan-source>` delimiter lines
+            (the *authoring form*, the only form which is ever edited and
+            persisted) and set <task-render/> to the content enclosed in
+            the `<task-plan-render>` delimiter lines (the
+            *rendering-prepared* form, used for *display only*). The
+            delimiter lines themselves are *never* part of either form.
+            Do not output anything related to this MCP tool call. Set
+            <status>plan loaded</status>.
         </else>
 
         Set <task-content-dirty>false</task-content-dirty>.
@@ -200,6 +209,7 @@ Set <args></args> (set args to empty).
         -   If <text/> starts with `ERROR:` or `WARNING:`:
             Silently ignore the MCP error.
             Set <task-content/> to empty.
+            Set <task-render/> to empty.
             Set <words/> to "0".
             Do not output anything.
 
@@ -232,7 +242,7 @@ Set <args></args> (set args to empty).
         *Determine previous-plan handling*:
 
         -   If <getopt-option-plan/> matches the regex `^(OVERWRITE|REFINE|PRESERVE)$`:
-            Honor the pre-selection what to do with the previous plan.
+            Honor the pre-selection of what to do with the previous plan.
             Set <result><getopt-option-plan/></result>.
 
         -   If <getopt-option-plan/> is equal to `none`:
@@ -322,32 +332,70 @@ Set <args></args> (set args to empty).
     `PREFLIGHT`, or declines/cancels in the dialog of step 3.4:
 
     1.  *Update timestamp*:
-        <if condition="<task-content/> contains '⚙   Modified:' AND <task-content-dirty/> is 'true'">
+        <if condition="the frontmatter of <task-content/> carries a `Modified:` key AND <task-content-dirty/> is 'true'">
         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. Update
-        the `⚙   Modified: ...` line of <task-content/> with the new
-        `⚙   Modified: <timestamp-modified/>`.
+        MCP server and using the `text` field of its response. Update
+        the `Modified: ...` frontmatter key of <task-content/> with the
+        new <timestamp-modified/> value.
         Do not output anything.
         </if>
 
     2.  *Persist plan*:
         <if condition="<task-content-dirty/> is 'true'">
-        Call the `ase_task_save(id: "<ase-task-id/>", text: "<task-content/>")` tool
-        of the `ase` MCP server to persist the current plan, and then
-        set <task-content-dirty>false</task-content-dirty> again. Calculate the
-        number of words <words/> of <task-content/>. Do not output anything
-        related to this MCP tool call except the following <template/>:
+        Call the `ase_task_save(id: "<ase-task-id/>", text:
+        "<task-content/>", render: true)` tool of the `ase` MCP server to
+        persist the current plan -- <task-content/> always is the
+        *authoring form* of the plan and hence is persisted *as is* --
+        and then set <task-content-dirty>false</task-content-dirty>
+        again. Finally, set <task-render/> to the `text` *output* field
+        of this `ase_task_save` tool call -- the rendering-prepared form
+        of the just-persisted plan, which is for *display only* and
+        *MUST NOT* be confused with the `text` *argument* passed into
+        that call -- so the rendering in step 3.3 stays consistent across
+        all loop rounds. Calculate the number of words <words/> of
+        <task-content/>. Do not output anything related to this MCP tool
+        call except the following <template/>:
 
         <template>
         ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan saved**
         </template>
         </if>
 
-    3.  *Render plan*: Treat <task-content/> as *verbatim* Markdown.
+    3.  *Render plan*:
+        <if condition="<task-render/> is empty">
+        Call the `ase_markdown_prepare(text: "<task-content/>")` tool of
+        the `ase` MCP server and set <task-render/> to the `text` output
+        field of this tool call. Do not output anything related to this
+        MCP tool call.
+        </if>
+
+        Treat <task-render/> as *verbatim* Markdown.
+
+        For the *rendering only*, drop the leading *frontmatter* block --
+        both `---` delimiters and all of their keys -- and instead place
+        the following column-aligned glyph lines *before* the
+        `#   TASK: <title/>` heading, separated from it by an empty line,
+        omitting the line of every key absent from the frontmatter. The
+        glyph lines *MUST* stay *above* the heading, exactly where the
+        frontmatter block sits in the plan file, and *MUST NOT* be moved
+        below it. This keeps the `---` delimiters from rendering as a
+        horizontal rule plus a *setext heading*. This rewrite is
+        *display-only* and *MUST NOT* change <task-render/> or
+        <task-content/> itself:
+
+        <format>
+        ◉   **Id:**         <task-id/>
+        ⎈   **Created:**    <timestamp-created/>
+        ⚙   **Modified:**   <timestamp-modified/>
+        ◐   **Status:**     <task-status/>
+        ⚑   **Properties:** <task-properties/>
+        ☯   **Kind:**       <task-kind/>
+        </format>
+
         Only output the following <template/>, so the user
-        can read the plan and react to it. If <task-content/> is longer
+        can read the plan and react to it. If <task-render/> is longer
         than 90 lines and a `##  IMPLEMENTATION DRAFT` section (from the
         companion skill `ase-task-preflight`) exists, replace the entire
         content of the `##  IMPLEMENTATION DRAFT` section with `[...]`.
@@ -355,9 +403,9 @@ Set <args></args> (set args to empty).
         Use the following <template/>:
 
         <template>
-        <ase-tpl-head title="TASK"/>
-        <task-content/>
-        <ase-tpl-foot title="TASK"/>
+        <ase-tpl-head title="TASK" subtitle="<task-id/>"/>
+        <task-render/>
+        <ase-tpl-foot title="TASK" subtitle="<task-id/>"/>
         </template>
 
     4.  *Determine next step*:

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

@@ -32,6 +32,7 @@ task plan until reaching a shared understanding.
 </objective>
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
 
 Procedure
 ---------
@@ -45,80 +46,23 @@ Set <args>--int-reuse-task</args>.
 
 1.  **Determine Task:**
 
-    1.  Set <id><getopt-arguments/></id> initially.
+    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:
 
-        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.  <elseif 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>
-            </elseif>
+        <expand name="task-react-id" arg1="ase-task-grill"></expand>
 
 2.  **Determine Task Plan:**
 
     1.  Determine the current task plan content:
 
-        <if condition="
-            <getopt-option-int-reuse-task/> is equal `true`
-            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
-            exists earlier in the current session
-        ">
-            Set <text/> to the `text` *output* field of the most recent
-            `ase_task_save(id: '<ase-task-id/>', ...)` tool call -- this
-            is the rendering-prepared plan content and *MUST NOT* be
-            confused with the `text` *argument* passed into that call --
-            *without* calling `ase_task_load` again. Set <status>plan
-            reused</status>. Do not output anything.
-        </if>
-        <else>
-            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 this `ase_task_load`
-            tool call. Do not output anything related to this MCP tool
-            call. Set <status>plan loaded</status>.
-        </else>
-
-        -   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/>.
-            Then output the following <template/>:
+        <expand name="task-load-content"></expand>
 
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
-            </template>
-
-    2.  <if condition="<plan/> is empty">
+    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
@@ -128,16 +72,16 @@ Set <args>--int-reuse-task</args>.
 3.  **Iterate Over Task Plan Aspects:**
 
     Interactively interview the user *relentlessly* about every
-    *essential aspect* of the task plan in <plan/> *until* reaching a
+    *essential aspect* of the task plan in <task-content/> *until* reaching a
     shared understanding and no decisions/questions are left open.
 
-    This especially means, you *MUST* clarify as many aspects as
+    This especially means that you *MUST* clarify as many aspects as
     necessary to ensure that for at least the most important decisions,
-    during a subsequent implementation, no essential freedom of choices
-    exist any longer.
+    during a subsequent implementation, no essential freedom of choice
+    exists any longer.
 
     For this process, determine the <n/> essential aspects <aspect-N/>
-    (a one or two word long short identifier like `Foo` or `Bar-Baz`)
+    (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.
 
@@ -165,7 +109,7 @@ Set <args>--int-reuse-task</args>.
     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.
+    the corresponding answer <answer-N/>, one at a time.
 
     1.  For each question <question-N/> in the iteration cycle <N/>:
 
@@ -177,7 +121,7 @@ Set <args>--int-reuse-task</args>.
 
         2.  Determine the answer alternatives:
 
-            1.  Check the <plan/> for the answer <answer-N-1/>.
+            1.  Check the <task-content/> 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
@@ -214,71 +158,33 @@ Set <args>--int-reuse-task</args>.
                 <ase-tpl-bullet-normal/> ASPECT <N/>/<n/>: **<aspect-N/>**, ANSWER: **<answer-N/>**
                 </template>
 
-    2.  Finally, update the plan in <plan/> based on all answers <answer-N/>.
+    2.  Finally, update <task-content/> based on all answers <answer-N/>.
 
-    3.  <if condition="<plan/> contains '⎈   Created:  <text/>'">
+    3.  <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
         Set <timestamp-created><text/></timestamp-created> (set
-        timestamp-created to extracted text)
+        timestamp-created to extracted text).
         </if>
 
-    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. If <timestamp-created/> is
-        still unset (because the previous <plan/> had no `Created:`
-        line), set <timestamp-created><timestamp-modified/></timestamp-created>
-        (fall back to the modified timestamp). 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/>")` tool of the `ase` MCP server to save the updated
-        task plan content. Do not output anything related to this MCP
-        call.
+    4.  *Add* the value `grilled` to the `Properties:` frontmatter key of
+        <task-content/> if it is still absent, keeping all already
+        present values and *creating* the whole key (with the single
+        value `grilled`) if the plan carries none.
 
-    6.  Only output the following <template/> and continue processing:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated**
-        </template>
+    5.  <expand name="task-save-content" arg1="plan updated"></expand>
 
 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`:
-
-            In the following, you *MUST* *NOT* use your built-in
-            <user-dialog-tool/> tool! Instead, you *MUST* just show a
-            custom dialog according to the expanded `custom-dialog`
-            definition. You *MUST* closely follow this definition:
-
-            <expand name="custom-dialog" arg1="--no-other">
-                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>
+        <expand name="task-next-select"
+            arg1="ase-task-grill"
+            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:
 

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

@@ -24,7 +24,8 @@ 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,
+updated and persisted, its `Properties:` frontmatter key gains the value
+`grilled`, and the user is offered a hand-off to editing,
 implementation, or preflight.
 
 ##  OPTIONS

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

@@ -60,8 +60,18 @@ Procedure
 
 4.  <if condition="<request/> is NOT empty">
     -   Call the `ase_task_id(id: "<request/>", session: "<ase-session-id/>")`
-        tool from the `ase` MCP server. Check the response as mandated
-        above; only on a clean response set <ase-task-id><request/></ase-task-id>.
+        tool from the `ase` MCP server and set <text/> to its `text`
+        output. On an `ERROR:`/`WARNING:` response, silently ignore the
+        MCP error (deviating from the generic MCP error rule), keep the
+        <ase-task-id/> inherited from the current context, and only
+        output the following <template/> and then immediately *STOP*
+        processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ☻ skill: **ase-task-id**, ▶ ERROR: failed to switch to task `<request/>`
+        </template>
+
+    -   Only on a clean response set <ase-task-id><request/></ase-task-id>.
 
     -   Output:
         <template>