@rse/ase 0.9.43 → 0.9.45

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

@@ -41,20 +41,20 @@ Procedure
 
 <define name="apply-refinement">
 Treat the <instruction/> as a *refinement instruction* for
-the plan, and update <content/> in-place by *applying* the
+the plan, and update <task-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>.
+Calculate the number of words <words/> of <task-content/>.
+Set <task-content-dirty>true</task-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
+<task-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/>.
@@ -69,7 +69,7 @@ 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/>.
+<task-content/>.
 </if>
 
 Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
@@ -77,8 +77,18 @@ Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
 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>.
+and calculate the number of words <words/> of <task-content/>.
+Set <task-content-dirty>true</task-content-dirty>.
+</define>
+
+<define name="handoff-args">
+Set <args></args> (set args to empty).
+<if condition="the plan was saved via `ase_task_save` in step 3.2">
+    Set <args>--int-reuse-task</args>.
+</if>
+<if condition="<getopt-option-next/> is not equal `none`">
+    Set <args><args/> --next <getopt-option-next/></args>
+</if>
 </define>
 
 1.  **Determine Task and Instruction:**
@@ -183,24 +193,24 @@ Set <content-dirty>true</content-dirty>.
             call. Set <status>plan loaded</status>.
         </else>
 
-        Set <content-dirty>false</content-dirty>.
+        Set <task-content-dirty>false</task-content-dirty>.
 
-        -   If <text/> starts with `ERROR:`:
+        -   If <text/> starts with `ERROR:` or `WARNING:`:
             Silently ignore the MCP error.
-            Set <content/> to empty.
+            Set <task-content/> to empty.
             Set <words/> to "0".
             Do not output anything.
 
-        -   If <text/> starts NOT with `ERROR:`:
-            Set <content><text/></content> (set content to text).
-            Calculate the number of words <words/> of <content/>.
+        -   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/>.
             Only output the following <template/>:
 
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
             </template>
 
-    2.  <if condition="<content/> is empty AND <instruction/> is empty">
+    2.  <if condition="<task-content/> is empty AND <instruction/> is empty">
         Ask the user interactively, without a special tool, for the
         initial plan content with a single question:
 
@@ -214,9 +224,9 @@ Set <content-dirty>true</content-dirty>.
         </template>
         </if>
 
-    3.  <if condition="<content/> is not empty AND
+    3.  <if condition="<task-content/> is not empty AND
             <instruction/> is not empty AND
-            <instruction/> is not equal <content/>">
+            <instruction/> is not equal <task-content/>">
         *Determine previous-plan handling*:
 
         -   If <getopt-option-plan/> matches the regex `^(OVERWRITE|REFINE|PRESERVE)$`:
@@ -285,14 +295,14 @@ Set <content-dirty>true</content-dirty>.
             </template>
         </if>
 
-    4.  <if condition="no line of <content/> matches the case-insensitive regex `^\s*#+\s*TASK\b` AND <instruction/> is empty">
-        Set <instruction><content/></instruction> (set instruction to content).
-        Set <content></content> (set content to empty).
-        Set <content-dirty>true</content-dirty>.
+    4.  <if condition="no line of <task-content/> matches the case-insensitive regex `^\s*#+\s*TASK\b` AND <instruction/> is empty">
+        Set <instruction><task-content/></instruction> (set instruction to task content).
+        Set <task-content></task-content> (set task content to empty).
+        Set <task-content-dirty>true</task-content-dirty>.
         Do not output anything.
         </if>
 
-    5.  <if condition="<content/> is empty AND <instruction/> is not empty">
+    5.  <if condition="<task-content/> is empty AND <instruction/> is not empty">
         <expand name="generate-plan"/>
 
         Only output the following <template/> and continue processing:
@@ -310,22 +320,22 @@ Set <content-dirty>true</content-dirty>.
     `PREFLIGHT`, or declines/cancels in the dialog of step 3.4:
 
     1.  *Update timestamp*:
-        <if condition="<content/> contains '⚙   Modified:' AND <content-dirty/> is 'true'">
+        <if condition="<task-content/> contains '⚙   Modified:' 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 <content/> with the new
+        the `⚙   Modified: ...` line of <task-content/> with the new
         `⚙   Modified: <timestamp-modified/>`.
         Do not output anything.
         </if>
 
     2.  *Persist plan*:
-        <if condition="<content-dirty/> is 'true'">
-        Call the `ase_task_save(id: "<ase-task-id/>", text: "<content/>")` tool
+        <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 <content-dirty>false</content-dirty> again. Calculate the
-        number of words <words/> of <content/>. Do not output anything
+        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/>:
 
         <template>
@@ -333,9 +343,9 @@ Set <content-dirty>true</content-dirty>.
         </template>
         </if>
 
-    3.  *Render plan*: Treat <content/> as *verbatim* Markdown.
+    3.  *Render plan*: Treat <task-content/> as *verbatim* Markdown.
         Only output the following <template/>, so the user
-        can read the plan and react to it. If <content/> is longer
+        can read the plan and react to it. If <task-content/> 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 `[...]`.
@@ -344,7 +354,7 @@ Set <content-dirty>true</content-dirty>.
 
         <template>
         <ase-tpl-head title="TASK"/>
-        <content/>
+        <task-content/>
         <ase-tpl-foot title="TASK"/>
         </template>
 
@@ -405,13 +415,7 @@ Set <content-dirty>true</content-dirty>.
         -   If <result/> is `GRILL`:
 
             *Break* out of the *loop*.
-            Set <args></args> (set args to empty).
-            <if condition="the plan was saved via `ase_task_save` in step 3.2">
-                Set <args>--int-reuse-task</args>.
-            </if>
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-grill", args: "<args/>")` tool
             to *grill* the finalized plan.
@@ -423,13 +427,7 @@ Set <content-dirty>true</content-dirty>.
         -   If <result/> is `PREFLIGHT`:
 
             *Break* out of the *loop*.
-            Set <args></args> (set args to empty).
-            <if condition="the plan was saved via `ase_task_save` in step 3.2">
-                Set <args>--int-reuse-task</args>.
-            </if>
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-preflight", args: "<args/>")` tool
             to *apply* the finalized plan.
@@ -441,13 +439,7 @@ Set <content-dirty>true</content-dirty>.
         -   If <result/> is `IMPLEMENT`:
 
             *Break* out of the *loop*.
-            Set <args></args> (set args to empty).
-            <if condition="the plan was saved via `ase_task_save` in step 3.2">
-                Set <args>--int-reuse-task</args>.
-            </if>
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool
             to *apply* the finalized plan.

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

@@ -36,6 +36,13 @@ task plan until reaching a shared understanding.
 Procedure
 ---------
 
+<define name="handoff-args">
+Set <args>--int-reuse-task</args>.
+<if condition="<getopt-option-next/> is not equal `none`">
+    Set <args><args/> --next <getopt-option-next/></args>
+</if>
+</define>
+
 1.  **Determine Task:**
 
     1.  Set <id><getopt-arguments/></id> initially.
@@ -223,7 +230,7 @@ Procedure
         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
+        text: "<plan/>")` tool of the `ase` MCP server to save the updated
         task plan content. Do not output anything related to this MCP
         call.
 
@@ -282,10 +289,7 @@ Procedure
             </template>
 
         -   If <result/> is `EDIT`:
-            Set <args>--int-reuse-task</args>.
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             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*
@@ -297,10 +301,7 @@ Procedure
             </template>
 
         -   If <result/> is `PREFLIGHT`:
-            Set <args>--int-reuse-task</args>.
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-preflight", args: "<args/>")` tool
             to *apply* the plan.
@@ -310,10 +311,7 @@ Procedure
             </template>
 
         -   If <result/> is `IMPLEMENT`:
-            Set <args>--int-reuse-task</args>.
-            <if condition="<getopt-option-next/> is not equal `none`">
-                Set <args><args/> --next <getopt-option-next/></args>
-            </if>
+            <expand name="handoff-args"/>
             Only output the following <template/> and then call the
             `Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool
             to *apply* the plan.

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

@@ -26,6 +26,9 @@ Configure Task Id
 *Get* or *set* the unique *task id* of the current session.
 </objective>
 
+Procedure
+---------
+
 1.  Determine request:
     <request><getopt-arguments/></request>
     Inherit the always existing <ase-session-id/> and the current
@@ -43,9 +46,10 @@ Configure Task Id
 3.  <if condition="<request/> is empty">
     -   Call the `ase_task_id(session: "<ase-session-id/>")`
         tool from the `ase` MCP server and set <text/> to its
-        `text` output. Check the response as mandated above; only
-        on a clean response set <ase-task-id><text/></ase-task-id>.
-        On an `ERROR:`/`WARNING:` response, keep the <ase-task-id/>
+        `text` output. Only on a clean response set
+        <ase-task-id><text/></ase-task-id>. On an `ERROR:`/`WARNING:`
+        response, silently ignore the MCP error (deviating from the
+        generic MCP error rule) and keep the <ase-task-id/>
         inherited from the current context as the fallback.
 
     -   Output:

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

@@ -31,99 +31,30 @@ with a corresponding, complete *change set*.
 </objective>
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
 
 Procedure
 ---------
 
 1.  **Determine Task:**
 
-    1.  Set <instruction><getopt-arguments/></instruction> 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="
-                <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
-            ">
-            Set <ase-task-id><instruction/></ase-task-id> (set task
-            id to instruction) and <instruction></instruction> (set
-            instruction empty), call the `ase_task_id(id: "<ase-task-id/>",
-            session: "<ase-session-id/>")` tool from the `ase` MCP
-            server to switch the task, and then only output the
-            following <template/>:
+        <expand name="task-react-id" arg1="ase-task-implement"></expand>
 
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **task given**
-            </template>
-            </if>
-
-        2.  <elseif condition="
-                <instruction/> has the format `<id/>: <text/>` where
-                <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$` and
-                <text/> is *empty*
-            ">
-            Set <instruction></instruction> (set instruction to empty)
-            and <ase-task-id><id/></ase-task-id> (set task id to
-            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>
-            </elseif>
-
-        3.  <elseif condition="<instruction/> is NOT empty">
-            The argument is neither empty nor a valid task id. As this
-            skill only accepts an optional `[<id>]` argument and *never*
-            a free-text instruction, only output the following <template/>
-            and then immediately *STOP* processing the entire current skill:
-
-            <template>
-            ⧉ **ASE**: ☻ skill: **ase-task-implement**, ▶ ERROR: expected single `[<id>]` argument
-            </template>
-            </elseif>
-
-2.  **Determine Operation**:
+2.  **Determine Operation:**
 
     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` argument of the most recent
-            `ase_task_save(id: '<ase-task-id/>', ...)` tool 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:`:
-            Set <content></content> (set content to empty).
-            Set <words/> to "0".
-
-        -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
-            Set <content><text/></content> (set content to text).
-            Calculate the number of words <words/> of <content/>.
-
-        Only output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
-        </template>
+        <expand name="task-load-content"></expand>
 
-    2.  If the <content/> is still empty, complain and tell the user to
+    2.  If the <task-content/> is still 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.
@@ -134,15 +65,15 @@ Procedure
         by modifying the *artifacts* with a corresponding, complete
         *change set*.
 
-        For this, primarily follow and honor the task plan in <content/>.
+        For this, primarily follow and honor the task plan in <task-content/>.
 
         Secondarily, derive hints from the optionally existing
         `IMPLEMENTATION DRAFT` section (from skill `ase-task-preflight`)
-        in <content/>. But the specification text in <content/> always
+        in <task-content/>. But the specification text in <task-content/> always
         overrules the implementation draft in the `IMPLEMENTATION DRAFT`
-        section of <content/>.
+        section of <task-content/>.
 
-        <if condition="<content/> does NOT contain a `##  VERIFICATION` section heading">
+        <if condition="<task-content/> does NOT contain a `##  VERIFICATION` section heading">
         The task plan deliberately *omits* the `##  VERIFICATION`
         section. You *MUST* therefore *strictly skip* the entire
         verification phase after modifying the source files: do *NOT*
@@ -162,37 +93,13 @@ Procedure
 
     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|DELETE)$`:
-                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-implement**, ▶ 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 and PRESERVE task plan.
-                DELETE: Stop processing and DELETE the task plan.
-            </expand>
+        <expand name="task-next-select"
+            arg1="ase-task-implement"
+            arg2="DONE|DELETE">
+            Next Step: How would you like to proceed with the plan?
+            DONE: Stop processing and PRESERVE task plan.
+            DELETE: Stop processing and DELETE the task plan.
+        </expand>
 
     2.  Check the tool <result/> and dispatch accordingly:
 

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

@@ -34,8 +34,8 @@ delete the task plan, unless `--next` pre-selects this choice.
     Automatically answer the user dialog for the next step. *option*
     is a single token or a *comma-separated chronological list* of
     tokens; the *first* token is consumed by this skill, and any
-    remaining tokens are *forwarded* (via `--next`) to the downstream
-    skill so an entire pipeline can be pre-scripted in one shot.
+    remaining tokens are intentionally *discarded*, because the
+    downstream `ase-task-delete` skill accepts no `--next` option.
     Recognized tokens at this skill: `none` (default, interactive
     answer required), `DONE` (preserve task plan and stop), or
     `DELETE` (hand off to `ase-task-delete`).

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

@@ -27,6 +27,9 @@ List Task Plans
 *List* all available *task plans* of the current project.
 </objective>
 
+Procedure
+---------
+
 1.  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` field, and -- if