@rse/ase 1.0.7 → 2.0.0

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

@@ -0,0 +1,111 @@
+---
+name: ase-task-assign
+argument-hint: "[--help|-h] [<id>:] <assignee>"
+description: >
+    Assign the current or given task plan to oneself or to somebody else,
+    with assigning it to oneself tracking the AI usage (time, tokens, and
+    costs) of the session until the task is given back, which adds the
+    accumulated usage to the usage attachment of the task. Use when the user
+    wants to "assign", "take", "pick up", "give back", "hand over", or
+    "unassign" the "task" or "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-getopt.md
+
+<purpose name="ase-task-assign">
+Assign a Task Plan
+</purpose>
+
+<expand name="getopt" arg1="ase-task-assign">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Assign* the task plan and *account* the AI usage of the session onto it.
+</objective>
+
+Procedure
+---------
+
+1.  **Determine Task and Assignee:**
+
+    1.  Parse <arguments><getopt-arguments/></arguments> (with any
+        leading and trailing whitespace stripped) into a
+        whitespace-separated list of tokens. Inherit the always
+        existing <ase-task-id/>, <ase-session-id/>, <ase-user-id/>, and
+        <ase-agent-tool/> from the current context. Set
+        <id><ase-task-id/></id> and <assignee></assignee> (empty).
+        Do not output anything.
+
+    2.  <if condition="<arguments/> contains two tokens and the first token ends with `:`">
+        Set <id/> to the first token with the trailing `:` removed and
+        <assignee/> to the second token. Do not output anything.
+        </if>
+
+    3.  <elseif condition="<arguments/> contains exactly one token which does NOT end with `:`">
+        Set <assignee/> to the token. Do not output anything.
+        </elseif>
+
+    4.  <else>
+        Only output the following <template/> and then immediately
+        *STOP* processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ☻ skill: **ase-task-assign**, ▶ ERROR: expected `[<id>:] <assignee>` arguments (use `none` to unassign)
+        </template>
+        </else>
+
+    5.  <if condition="<id/> does NOT match the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$`">
+        Only output the following <template/> and then immediately
+        *STOP* processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ☻ skill: **ase-task-assign**, ▶ ERROR: invalid task id `<id/>` (expected `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$`)
+        </template>
+        </if>
+
+2.  **Perform Assignment:**
+
+    1.  Call the `ase_task_assign(id: "<id/>", assignee: "<assignee/>",
+        session: "<ase-session-id/>", tool: "<ase-agent-tool/>")` tool
+        of the `ase` MCP server and set <text/> to the `text` output
+        field of this tool call. As giving a task back waits for late
+        telemetry, this call takes about 10 seconds then. Do not output
+        anything related to this MCP tool call.
+
+    2.  -   If <text/> starts with `ERROR:`:
+            Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<id/>**, ▶ status: **<text/>**
+            </template>
+
+        -   If <text/> starts NOT with `ERROR:`:
+            <if condition="<assignee/> is equal `me` or <ase-user-id/>, and <id/> is NOT equal <ase-task-id/>">
+            Call the `ase_task_id(id: "<id/>", session: "<ase-session-id/>")`
+            tool of the `ase` MCP server to switch the task, so the usage
+            window of the task observes assignee changes made elsewhere, and
+            set <ase-task-id><id/></ase-task-id>. Do not output anything
+            related to this MCP tool call.
+            </if>
+
+            Set <result/> to the first line of <text/> with the leading
+            `OK: ` prefix stripped and only output the following
+            <template/>:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<id/>**, ☺ assignee: **<assignee/>** (*updated*), ▶ <result/>
+            </template>
+
+            If <text/> carries a line `NOTICE: <info/>`, additionally
+            output:
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<id/>**, ▶ NOTICE: <info/>
+            </template>
+

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

@@ -0,0 +1,119 @@
+
+##  NAME
+
+`ase-task-assign` - Assign a Task Plan
+
+##  SYNOPSIS
+
+`ase-task-assign`
+    [`--help`|`-h`]
+    [*id*`:`] *assignee*
+
+##  DESCRIPTION
+
+The `ase-task-assign` skill assigns a *task plan* to an *assignee*, i.e.
+sets its `Assignee:` frontmatter key, via the `ase_task_assign` MCP tool,
+leaving its `Modified:` key alone, as that key tracks changes of the plan
+body only. Additionally, it *accounts* the *AI usage* of the session onto
+the task:
+
+-   Assigning the task to *oneself* (`me` or the current user id) opens
+    the *usage window* of the task, or attaches the session to an already
+    open one (e.g. of a previous session). From then on, all turns of the
+    session are accounted: the AI request time, the cache read, cache
+    write, input, and output tokens, and the costs, as reported by the
+    agent tool via *OpenTelemetry* to the ASE service, plus, in addition,
+    the human time (the whole real time of the window, as the engineer
+    costs money even while waiting for the AI) and its costs at the
+    hourly rate of the assignee in `telemetry.prices.hr` (default: 110 USD).
+
+-   Assigning the task to *anybody else*, or to *nobody* with `none`
+    (removing the `Assignee:` key), *gives it back*: it closes the usage
+    window and, after a grace period of 10 seconds for late telemetry,
+    adds the accumulated usage to the usage attachment of the task
+    (`Type: application/yaml; kind="usage"`), whose YAML data carries the
+    amounts `time: { ai, hr, real }` (minutes), `token: { cread, cwrite,
+    input, output }` (counts), and `cost: { ai, hr }` (USD). Each
+    booking *adds* to the existing amounts, atomically, so concurrent
+    changes of the task (e.g. by the agents of `ase agent`) are never lost.
+
+A usage window also closes and books when its last session *ends*, and
+when the `Assignee:` of the task is changed *elsewhere* (e.g. on the task
+board) while the task is the current task of the session. Conversely,
+changing the `Assignee:` of a task to oneself *elsewhere* (e.g. on the
+task board) opens its usage window, too, and attaches every session of
+the project whose current task it is (also a session switching to it,
+or starting with it, later on), with the window starting *paused*, i.e.,
+accounting from the next AI request of its sessions on. An *unassigned*
+task is even accounted *implicitly*, without any assignment: while it is
+the current task of a session, the session is attached to its usage
+window in the same way, until the session switches to another task, the
+task gets assigned to anybody else, or the session ends (configurable via
+`telemetry.implicit`, default: `true`, never for task `default`), so
+explicitly assigning a task to oneself is needed only for claiming it,
+e.g. against the agents of `ase agent`. Long windows
+additionally book every `telemetry.service.interval` minutes (default: 10).
+Without any AI request for `telemetry.service.idle` minutes (default: 30),
+a usage window *pauses*, and the next AI request (of any kind, not just
+ASE skills) silently *resumes* it, so forgetting a task assigned to
+oneself does not account an idle session endlessly. A usage window without
+any AI request for 7 days is closed and booked.
+
+The accounting is *opt-in*: it requires the configuration key
+`telemetry.enabled` to be `true` (via `ase config set telemetry.enabled
+true`) and the telemetry export of the agent tool to be activated once
+via `ase setup telemetry activate --tool` *tool*, otherwise only the
+assignee is set and a `NOTICE` is reported. If *id*`:` is omitted, the *current* task id
+(inherited from the session context) is used, otherwise, on a successful
+assignment to *oneself*, the current task id of the session is switched
+to *id*.
+
+##  ARGUMENTS
+
+-   *id*`:`:
+    The unique identifier of the task plan, with a trailing colon.
+    If omitted, the current task id is used.
+
+-   *assignee*:
+    The assignee: `me` for oneself, `none` for nobody, or any other
+    name of a human or agent. If the configuration key `project.users`
+    lists the known users, a name which is neither one of them nor the
+    name of an agent present at the agent relay is still assigned, but
+    reported with a `NOTICE`.
+
+##  SCENARIOS
+
+-   You start working on a task and want its AI usage tracked
+-   You hand a task over to a colleague or an agent, booking your usage
+-   You want to know the AI time, tokens, and costs spent on a task
+
+##  EXAMPLES
+
+Take the current task plan and track the AI usage of the session:
+
+```text
+❯ /ase-task-assign me
+```
+
+Take a specific task plan:
+
+```text
+❯ /ase-task-assign hello: me
+```
+
+Give the task plan back to a colleague, booking the AI usage:
+
+```text
+❯ /ase-task-assign alice
+```
+
+Unassign the task plan, booking the AI usage:
+
+```text
+❯ /ase-task-assign hello: none
+```
+
+##  SEE ALSO
+
+[`ase-task-status`](../ase-task-status/help.md), [`ase-task-id`](../ase-task-id/help.md), [`ase-task-view`](../ase-task-view/help.md),
+[`ase-task-list`](../ase-task-list/help.md).

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)... --int-reuse-task">
+    arg2="--next|-n=(none|DONE|EDIT|IMPLEMENT|DRAFT)... --int-reuse-task">
     $ARGUMENTS
 </expand>
 
@@ -74,8 +74,7 @@ Set <args></args> (set args to empty).
         </if>
 
     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
+        Complain and tell the user to use the `ase-task-edit` skill
         first to create a task plan. Then immediately stop processing
         this skill.
         </if>
@@ -88,17 +87,17 @@ Set <args></args> (set args to empty).
         and unchanged*. Honor the following ruleset *strictly*:
 
         1.  *Preserve-exactly (never alter)*: the plan <format/>
-            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.
-
-        2.  *Compress free-text only* (the `**WHAT**`/`**WHY**` prose and
-            each bullet's `<specification/>` text):
+            structure (the entire frontmatter block with all of its keys,
+            the headings `#`/`##`, all three `##  SPECIFICATION (WHAT)`,
+            `##  DESIGN (HOW)`, and `##  VERIFICATION (WHEN)` sections,
+            the `-   <box/> <type/>:` bullet-point prefixes with their
+            checkbox states, and the entire "backmatter" with all of its
+            attachment blocks), all *code spans* and code blocks,
+            technical terms, file paths, identifiers, numbers,
+            severities (`LOW`/`MEDIUM`/`HIGH`/`ACCEPTED`), and the
+            `*<aspect/>*` emphasis highlighting convention.
+
+        2.  *Compress free-text only* (each bullet-point's <text/>):
             -   *Drop* filler ("just", "really", "basically", "simply"),
                 pleasantries, and hedging ("I think", "maybe", "perhaps").
             -   *Use* shorter synonyms and common abbreviations.
@@ -151,11 +150,11 @@ Set <args></args> (set args to empty).
 
         <expand name="task-next-select"
             arg1="ase-task-condense"
-            arg2="DONE|EDIT|IMPLEMENT|PREFLIGHT">
+            arg2="DONE|EDIT|IMPLEMENT|DRAFT">
             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.
+            DRAFT: Hand off plan to implementation drafting.
             IMPLEMENT: Hand off plan to implementation.
         </expand>
 
@@ -190,12 +189,13 @@ Set <args></args> (set args to empty).
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to implementation**
             </template>
 
-        -   If <result/> is `PREFLIGHT`:
+        -   If <result/> is `DRAFT`:
             <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.
+            Set <args><args/> --draft</args>. Only output the following
+            <template/> and then call the
+            `Skill(skill: "ase:ase-task-implement", args: "<args/>")` tool
+            to *draft* the implementation of the plan.
 
             <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to pre-flight**
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan condensed -- hand-off to implementation draft**
             </template>

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

@@ -16,13 +16,15 @@ The `ase-task-condense` skill *compresses* the wording of an existing
 task plan to make it require as little reading as possible, while
 keeping *all semantics fully preserved and unchanged*. It loads the
 current (or given) plan, applies a self-contained, telegrapher-like
-"remove-fluff" ruleset to the *free-text* parts only (the `**WHAT**` /
-`**WHY**` prose and each bullet's specification text), and writes the
-shorter plan back via `ase_task_save`.
-
-The plan *structure* is never altered: all headings, section markers,
-`- **<aspect>**:` bullet labels, code spans, technical terms, file
-paths, numbers, and severities are kept exactly. Only genuinely
+"remove-fluff" ruleset to the *free-text* parts only (the text of each
+`DOM`, `IFC`, `ARC`, `IMP`, `REG`, and `CON` bullet point), and writes
+the shorter plan back via `ase_task_save`.
+
+The plan *structure* is never altered: the frontmatter, all headings,
+the `SPECIFICATION (WHAT)`, `DESIGN (HOW)`, and `VERIFICATION (WHEN)`
+sections, the `- [ ] DOM:`-style bullet prefixes with their checkbox
+states, all attachments, code spans, technical terms, file paths,
+numbers, and severities are kept exactly. Only genuinely
 redundant bullets may be merged, and a shortening that would change
 meaning is always rejected in favor of the longer wording. The condense
 ruleset *overrides* the active session persona, so the plan is compressed
@@ -33,8 +35,8 @@ further reduction is possible, the plan is left untouched (including its
 `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
-`--next` pre-selects this choice.
+`ase-task-edit` or `ase-task-implement` (optionally with `--draft`),
+unless `--next` pre-selects this choice.
 
 ##  OPTIONS
 
@@ -47,7 +49,7 @@ After condensing, the user is asked whether to stop or hand off to
     Recognized tokens at this skill: `none` (default, interactive
     answer required), `DONE` (stop), `EDIT` (hand off to
     `ase-task-edit`), `IMPLEMENT` (hand off to `ase-task-implement`),
-    or `PREFLIGHT` (hand off to `ase-task-preflight`). Example:
+    or `DRAFT` (hand off to `ase-task-implement --draft`). Example:
     `--next EDIT,DONE` condenses, hands off to editing, and the editing
     loop will exit immediately.
 

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

@@ -42,7 +42,7 @@ Procedure
         Do not output anything.
         </if>
 
-    3.  <if condition="<id/> does NOT match the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`">
+    3.  <if condition="<id/> does NOT match the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$`">
         Only output the following <template/> and then immediately
         *STOP* processing the entire current skill:
 

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

@@ -50,7 +50,7 @@ Procedure
     2.  React on the task id:
 
         <if condition="
-            <instruction/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*:?$`
+            <instruction/> matches the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*:?$`
         ">
         The lone token is the *task id* (with an optional and ignored
         trailing `:`), never a hint. Set
@@ -68,7 +68,7 @@ Procedure
 
         <elseif condition="
             <instruction/> has the format `<id/>: <text/>` where
-            <id/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
+            <id/> matches the regexp `^[a-zA-Z0-9#][a-zA-Z0-9#_-]*$`
         ">
         Set <instruction><text/></instruction> (set instruction to
         text) and <ase-task-id><id/></ase-task-id> (set task id to
@@ -106,8 +106,7 @@ Procedure
         <expand name="task-load-content"></expand>
 
     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
+        the user to use the `ase-task-edit` skill first to create a
         task plan. Then immediately stop processing this skill.
 
 3.  **Dissect Task Plan:**
@@ -120,12 +119,16 @@ Procedure
             arg2="<dissect-hint/>"
             arg3="<ase-task-id/>"
         >
-        the individual bullet points of the `##  CHANGES` and
-        `##  VERIFICATION` sections of the loaded plan <task-content/>
+        the individual bullet points of the `##  SPECIFICATION (WHAT)`,
+        `##  DESIGN (HOW)`, and `##  VERIFICATION (WHEN)` sections of the
+        loaded plan <task-content/>
         </expand>
 
-        Each `##  VERIFICATION` bullet point *MUST* land in the very part
-        which carries the `##  CHANGES` bullet points it verifies.
+        Each `##  DESIGN (HOW)` bullet point *MUST* land in the very part
+        which carries the `##  SPECIFICATION (WHAT)` bullet points it
+        realizes, and each `##  VERIFICATION (WHEN)` bullet point *MUST*
+        land in the very part which carries the `##  SPECIFICATION (WHAT)`
+        and `##  DESIGN (HOW)` bullet points it verifies.
 
         A *single* bullet point is *not* the smallest unit here: a bullet
         point which itself covers *multiple* domains or concerns *MAY* be
@@ -133,11 +136,21 @@ Procedure
         each of which is a complete bullet point of its own, is formed
         *exclusively* from the wording of the original bullet point, and
         is then assigned to a part like an ordinary bullet point. A split
-        `##  VERIFICATION` bullet point follows the `##  CHANGES` bullet
-        points its fragments verify, so its fragments *MAY* land in
-        *different* parts.
-
-    2.  *Report the parts*:
+        `##  DESIGN (HOW)` or `##  VERIFICATION (WHEN)` bullet point
+        follows the bullet points its fragments realize or verify, so its
+        fragments *MAY* land in *different* parts.
+
+    2.  *Identify the parts* according to the task id scheme of the
+        project: for *every* part in <parts/>, in their derived order,
+        call the `ase_task_newid(title: "<scope/>", proposal:
+        "<part-id/>", taken: [ <previous/> ])` tool of the `ase` MCP
+        server, where <previous/> lists the already re-identified
+        <part-id/> of all preceding parts (as the tool reserves ids for
+        scheme `seq` only), and replace the <part-id/> of the part with the `id` field
+        of its response -- you *MUST* *NEVER* assemble such an id
+        yourself. Do not output anything related to these MCP tool calls.
+
+    3.  *Report the parts*:
 
         <expand name="dissect-report" arg1="<ase-task-id/>"></expand>
 
@@ -204,50 +217,60 @@ 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
-                part's own input elements plus the `##  CONTEXT` section
-                of the epic,
-            -   the `##  CHANGES` section carries *exactly* the
-                `##  CHANGES` bullet points assigned to this part,
-                keeping their original wording, and
-            -   the `##  VERIFICATION` section carries *exactly* the
-                `##  VERIFICATION` bullet points assigned to this part,
-                keeping their original wording.
+            -   the <task-status/> is the *default* state of the task
+                lifecycle model <ase-project-task-lifecycle/>, as every
+                part is a *newly created* plan,
+            -   the `Group:` key carries <ase-task-id/>, the id of the
+                epic, so all parts are grouped under it,
+            -   the `Kind:`, `Phase:`, `Tags:`, `Source:`, `Changeset:`,
+                and `Target:` keys are taken over from the epic
+                *verbatim* (the kind being
+                inferred from the part content if the epic carries no
+                `Kind:` key), while the `After:` key of a part lists the
+                parts it depends on, if any,
+            -   the <task-title/> is derived from the part's <scope/>,
+            -   the `##  SPECIFICATION (WHAT)` section carries *exactly*
+                the `DOM` and `IFC` bullet points assigned to this part,
+            -   the `##  DESIGN (HOW)` section carries *exactly* the
+                `ARC` and `IMP` bullet points assigned to this part, and
+            -   the `##  VERIFICATION (WHEN)` section carries *exactly*
+                the `REG` and `CON` bullet points assigned to this part,
+
+            all bullet points keeping their original wording, checkbox
+            state, and type, and no "backmatter" being carried over from
+            the epic.
 
             For a bullet point which was *split* into fragments, the part
-            carries *only* its own fragment: the <specification/> keeps
-            the *original* wording of the portion this fragment covers,
-            with *no* re-interpretation and *no* added scope, and the
-            `**<aspect/>**` label is *narrowed* to exactly that portion.
-            Across all parts, the fragments of a split bullet point
-            *MUST* still reproduce the original bullet point *completely*
-            and *without* duplication.
-
-            <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
-            heading) from <part-content/>, too.
+            carries *only* its own fragment: the <text/> keeps the
+            *original* wording of the portion this fragment covers, with
+            *no* re-interpretation and *no* added scope, and the
+            `<box/> <type/>:` prefix is kept *unchanged*. Across all
+            parts, the fragments of a split bullet point *MUST* still
+            reproduce the original bullet point *completely* and
+            *without* duplication.
+
+            <if condition="<task-content/> does NOT contain a `##  VERIFICATION (WHEN)` section heading">
+            The epic itself deliberately *omits* the `##  VERIFICATION
+            (WHEN)` section, so you *MUST* omit this section (including
+            its heading) from <part-content/>, too.
             </if>
-            <elseif condition="no `##  VERIFICATION` bullet point was assigned to this part">
+            <elseif condition="no `##  VERIFICATION (WHEN)` bullet point was assigned to this part">
             This part carries *no* verification of its own, so you *MUST*
-            omit the `##  VERIFICATION` section (including its heading)
-            from <part-content/>, too -- an *empty* section would violate
-            the plan <format/>, and rule 5 forbids inventing a bullet
-            point.
+            omit the `##  VERIFICATION (WHEN)` section (including its
+            heading) from <part-content/>, too -- an *empty* section
+            would violate the plan <format/>, and rule 5 forbids
+            inventing a bullet point.
             </elseif>
 
         2.  Call the `ase_task_save(id: "<part-id/>", text:
-            "<part-content/>")` tool of the `ase` MCP server to persist
+            "<part-content/>", create: true)` tool of the `ase` MCP server to persist
             the sub-task plan -- this MCP tool call is the *only*
             permitted way to persist it, *NEVER* write the plan file
-            via `Write`/`Edit` or by executing a shell command. Do not
+            via `Write`/`Edit` or by executing a shell command. If this
+            call fails because the task already exists (a concurrent
+            session took the same id), re-identify this part as in step
+            3.2, replace its <part-id/> in <part-content/>, and save
+            again. Do not
             output anything related to this MCP tool call except the
             following <template/>:
 

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

@@ -22,8 +22,9 @@ it can be implemented, reviewed, and committed entirely on its own.
 
 The dissection follows a strict ruleset: at least *2* and at most
 *count* parts are derived, *every* bullet point of the epic's
-`##  CHANGES` and `##  VERIFICATION` sections is assigned to *exactly
-one* part, mutually dependent bullet points are kept together, and
+`##  SPECIFICATION (WHAT)`, `##  DESIGN (HOW)`, and
+`##  VERIFICATION (WHEN)` sections is assigned to *exactly one* part,
+mutually dependent bullet points are kept together, and
 nothing beyond the epic's own content is invented. A bullet point which
 itself covers *multiple* domains is *split* into fragments, which are
 then assigned individually -- together they still reproduce the original
@@ -42,9 +43,11 @@ never the ruleset itself.
 The derived parts are first reported as a *dissection table* (part
 number, sub-task id, scope, and rationale). Then -- unless `--dry` is
 given -- each part is materialized as its own *complete* sub-task plan
-(with its own `##  CONTEXT`, `##  CHANGES`, and `##  VERIFICATION`
-sections) and persisted under the task id `<task-id>-<feature-slug>`.
-The epic plan itself always stays *untouched*.
+(with its own `##  SPECIFICATION (WHAT)`, `##  DESIGN (HOW)`, and
+`##  VERIFICATION (WHEN)` sections, grouped under the epic via its
+`Group:` frontmatter key) and persisted under the task id
+`<task-id>-<feature-slug>`. The epic plan itself always stays
+*untouched*.
 
 ##  OPTIONS
 
@@ -54,9 +57,7 @@ The epic plan itself always stays *untouched*.
 
 -   `--dry`|`-d`:
     *Report only* -- print the dissection table but create *no*
-    artifacts at all, so the decision stays fully reversible. Note that
-    this meaning differs from `--dry`/`-d` in `ase-code-craft`, where it
-    instead omits the `##  VERIFICATION` section of the composed plan.
+    artifacts at all, so the decision stays fully reversible.
 
 -   `--force`|`-f`:
     Overwrite already existing sub-task plans. Without this option, the
@@ -117,5 +118,5 @@ Dissect a specific task plan with a hint:
 
 ##  SEE ALSO
 
-[`ase-code-dissect`](../ase-code-dissect/help.md), [`ase-task-edit`](../ase-task-edit/help.md), [`ase-task-condense`](../ase-task-condense/help.md),
+[`ase-repo-dissect`](../ase-repo-dissect/help.md), [`ase-task-edit`](../ase-task-edit/help.md), [`ase-task-condense`](../ase-task-condense/help.md),
 [`ase-task-implement`](../ase-task-implement/help.md), [`ase-task-list`](../ase-task-list/help.md), [`ase-task-delete`](../ase-task-delete/help.md).