@rse/ase 0.9.55 → 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,52 +48,21 @@ 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).
@@ -104,12 +73,6 @@ Set <args></args> (set args to empty).
         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
@@ -147,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
@@ -188,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-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`:
@@ -326,7 +336,7 @@ Set <args></args> (set args to empty).
         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
+        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.
@@ -334,18 +344,34 @@ Set <args></args> (set args to empty).
 
     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
@@ -356,7 +382,8 @@ Set <args></args> (set args to empty).
         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-content/> itself:
+        *display-only* and *MUST NOT* change <task-render/> or
+        <task-content/> itself:
 
         <format>
         ◉   **Id:**         <task-id/>
@@ -368,7 +395,7 @@ Set <args></args> (set args to empty).
         </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 `[...]`.
@@ -377,7 +404,7 @@ Set <args></args> (set args to empty).
 
         <template>
         <ase-tpl-head title="TASK" subtitle="<task-id/>"/>
-        <task-content/>
+        <task-render/>
         <ase-tpl-foot title="TASK" subtitle="<task-id/>"/>
         </template>
 

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,75 +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="the frontmatter of <plan/> carries a `Created: <text/>` key">
+    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:`
-        frontmatter key), 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 into the frontmatter keys `Id:`,
-        `Created:`, and `Modified:` and calculate the number of
-        words <words/> of <plan/>. Additionally *add* the value `grilled`
-        to the `Properties:` frontmatter key 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.
-
-    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.
-
-    6.  Only output the following <template/> and continue processing:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated**
-        </template>
+    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.
+
+    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-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>

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

@@ -75,7 +75,7 @@ Procedure
     </if>
 
     1.  Set <worktree-name><ase-task-id/></worktree-name>. The worktree
-        is *never* named by an own option value: it always carries the
+        is *never* named by its own option value: it always carries the
         unique *task id*, so the worktree directory and its branch stay
         unambiguously tied to the very task plan implemented in them.
         The task id is a plain identifier by construction, hence it is
@@ -89,7 +89,7 @@ Procedure
         `git rev-parse --show-toplevel`
 
         <if condition="this command fails">
-        The current directory is no Git repository, so no worktree can be
+        The current directory is not a Git repository, so no worktree can be
         created. Only output the following <template/> and then
         immediately *STOP* processing the entire current skill, leaving
         the working copy *untouched*:
@@ -204,17 +204,21 @@ Procedure
 
         -   Set the `Status:` key to `COMPLETED`, but *only* if the
             change set was applied *completely* and *successfully* --
-            this traverses the `start` and `complete` transitions of the
-            state machine of the plan <format/> in one go. Otherwise
-            leave the `Status:` key *untouched*, as an incomplete run
-            transitioned nowhere.
+            this traverses the `approve`, `start`, and `complete`
+            transitions of the state machine of the plan <format/> in one
+            go, starting from the `DRAFTED` state which a freshly authored
+            plan carries. Otherwise leave the `Status:` key *untouched*,
+            as an incomplete run transitioned nowhere.
 
         -   Refresh the `Modified:` key with the current time in
             ISO-style format, determined by calling the
             `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
             MCP server.
 
-        Then call the `ase_task_save(id: "<ase-task-id/>", text:
+        Apart from the frontmatter keys above, the plan body *MUST* stay
+        *exactly* as loaded.
+
+        Finally call the `ase_task_save(id: "<ase-task-id/>", text:
         "<task-content/>")` tool of the `ase` MCP server to persist the
         updated task plan. Do not output anything in this sub-step.
 

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

@@ -16,7 +16,7 @@
 The `ase-task-implement` skill performs the *final implementation* of
 a task plan by modifying the corresponding *artifacts* with a complete
 *change set*. The plan is loaded and any optional `IMPLEMENTATION DRAFT`
-section produced by `ase-task-preflight` is used as a hint - the plain
+section produced by `ase-task-preflight` is used as a hint -- the plain
 plan content always overrules the draft. Afterwards the plan's
 `Properties:` frontmatter key gains the value `implemented` (plus
 `verified`, if the verification phase actually ran and succeeded), and

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

@@ -55,6 +55,15 @@ Procedure
     ⧉ **ASE**: ✪ skill: **ase-task-list**, ▶ ERROR: options `--include` and `--exclude` cancel out to an empty state set
     </template>
 
+    Directly *after* this error <template/>, and *before* stopping, give
+    the corrective hint by expanding the following (which, depending on
+    the configured <ase-guidance-level/>, may expand into nothing and
+    hence emit no output at all):
+
+    <ase-tpl-hint level="minimal">
+    The `--exclude` default `COMPLETED,CANCELLED` still applies -- add `--exclude none` to reach states like `COMPLETED` via `--include`.
+    </ase-tpl-hint>
+
 2.  Call the `ase_task_list(verbose: <getopt-option-verbose/>)` tool from
     the `ase` MCP server. The result is a structured object with a
     `tasks` array where each entry has an `id` and a `status` field, and