@rse/ase 0.9.51 → 0.9.53

package/plugin/skills/ase-arch-analyze/help.md

@@ -7,6 +7,7 @@
 
 `ase-arch-analyze`
     [`--help`|`-h`]
+    [`--prefix`|`-P` *prefix*]
     *source-reference*
 
 ##  DESCRIPTION
@@ -24,6 +25,15 @@ governance, and package cohesion), renders a high-level architecture
 diagram, and reports findings as either `PROBLEM` or `TRADEOFF` entries
 based on a built-in tension matrix.
 
+The `--prefix`|`-P` *prefix* option prefixes every reported finding id
+with *prefix* and a hyphen, so `P1` becomes `<prefix>-P1` and `T1`
+becomes `<prefix>-T1`, with the persisted keys becoming
+`ase-issue-<prefix>-P1` and `ase-issue-<prefix>-T1` accordingly. The
+purge of stale results is narrowed to the same namespace, so analyses
+run under *distinct* prefixes coexist instead of overwriting each other.
+Without the option (the default), ids stay unprefixed and the purge
+covers the *entire* `ase-issue-*` space, including any prefixed results.
+
 ##  ARGUMENTS
 
 *source-reference*:
@@ -44,6 +54,12 @@ Analyze a specific module:
 ❯ /ase-arch-analyze src/core
 ```
 
+Analyze a module under an own id namespace, yielding `core-P1`, `core-T1`, ...:
+
+```text
+❯ /ase-arch-analyze --prefix core src/core
+```
+
 ##  SEE ALSO
 
 [`ase-arch-discover`](../ase-arch-discover/help.md), [`ase-code-analyze`](../ase-code-analyze/help.md), [`ase-code-resolve`](../ase-code-resolve/help.md),

package/plugin/skills/ase-arch-discover/SKILL.md

@@ -19,9 +19,9 @@ allowed-tools:
 @${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
-<skill name="ase-arch-discover">
+<purpose name="ase-arch-discover">
 Discover Components
-</skill>
+</purpose>
 
 <expand name="getopt"
     arg1="ase-arch-discover"

package/plugin/skills/ase-code-analyze/SKILL.md

@@ -17,13 +17,13 @@ allowed-tools:
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
-<skill name="ase-code-analyze">
+<purpose name="ase-code-analyze">
 Analyze Source Code
-</skill>
+</purpose>
 
 <expand name="getopt"
     arg1="ase-code-analyze"
-    arg2="--performance|-p --security|-s --severity|-S=(LOW|MEDIUM|HIGH)">
+    arg2="--performance|-p --security|-s --severity|-S=(LOW|MEDIUM|HIGH) --prefix|-P=">
     $ARGUMENTS
 </expand>
 
@@ -123,6 +123,14 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
 3.  <step id="STEP 3: Show Results">
 
+    Before reporting, determine the *problem id prefix* <id-prefix/>:
+    set <id-prefix><getopt-option-prefix/>-</id-prefix> if
+    <getopt-option-prefix/> is *not* empty, and set <id-prefix></id-prefix>
+    (set to empty) otherwise. Every reported problem id and every
+    persisted key below carries this <id-prefix/>, so that analyses run
+    under *distinct* prefixes occupy *distinct* id namespaces and hence
+    do not overwrite each other.
+
     Before reporting, determine the *effective severity floor* <floor/>:
     define the ordinal rank `LOW`=1, `MEDIUM`=2, `HIGH`=3, start from
     <floor><getopt-option-severity/></floor> (default `LOW`), and - if
@@ -143,15 +151,15 @@ problems in *performance* and *efficiency*, or problems in *security*.
     problem. Within the same severity, keep the `file`/`line` order
     established in STEP 2.
 
-    Then renumber the surviving problems contiguously as `P<n/>` with
-    <n/> = 1, 2, ... in that sorted ordering, so `P1` is the most severe
-    problem and the persisted `ase-issue-P<n/>` keys follow the reported
-    sequence. If *all* problems are dropped, skip the per-problem report
-    but still purge any stale
+    Then renumber the surviving problems contiguously as `<id-prefix/>P<n/>`
+    with <n/> = 1, 2, ... in that sorted ordering, so `<id-prefix/>P1` is
+    the most severe problem and the persisted `ase-issue-<id-prefix/>P<n/>`
+    keys follow the reported sequence. If *all* problems are dropped, skip
+    the per-problem report but still purge any stale
     persisted problems with a *single* `ase_kv_batch` call to the `ase`
     MCP server with `transactional` set to `true` and a `commands`
     parameter array holding exactly one `{ command: "clear", prefix:
-    "ase-issue-" }` entry,
+    "ase-issue-<id-prefix/>" }` entry,
     and still emit the final hint <template/> below.
 
     In this STEP 3, for *EVERY* surviving problem in <problems/>, set
@@ -165,7 +173,7 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
     <template>
 
-    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **P<n/>**: **<title/>**
+    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **<id-prefix/>P<n/>**: **<title/>**
 
     <description/>
 
@@ -180,7 +188,7 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
     <template>
 
-    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **P<n/>**: **<title/>**
+    <ase-tpl-bullet-signal/> **PROBLEM** (Severity: **<severity/>**): **<id-prefix/>P<n/>**: **<title/>**
 
     <description/>
 
@@ -193,23 +201,24 @@ problems in *performance* and *efficiency*, or problems in *security*.
     -   For the final results, do *not* output anything else, especially do
         *not* give any further explanations or information.
 
-    -   Uniquely identify the problems with `P<n/>` where <n/> is 1, 2, ...
+    -   Uniquely identify the problems with `<id-prefix/>P<n/>` where <n/> is 1, 2, ...
 
     -   *Additionally*, persist all reported problems in a *single*
         `ase_kv_batch` call to the `ase` MCP server with `transactional`
         set to `true`. The `commands` parameter array of this call
-        starts with one `{ command: "clear", prefix: "ase-issue-" }`
-        entry (which removes only the previously persisted `ase-issue-*`
-        keys, leaving any unrelated keys in the shared store intact),
-        followed by one `{ command: "set", key: "ase-issue-P<n/>", val:
-        "<title/>: <description/>" }` entry per reported problem.
+        starts with one `{ command: "clear", prefix: "ase-issue-<id-prefix/>" }`
+        entry (which removes only the previously persisted
+        `ase-issue-<id-prefix/>*` keys, leaving any unrelated keys in the
+        shared store intact),
+        followed by one `{ command: "set", key: "ase-issue-<id-prefix/>P<n/>",
+        val: "<title/>: <description/>" }` entry per reported problem.
 
     Finally, give a final 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">
-    For deeper analysis, suggestions on solution approaches and then final problem resolution, use `/ase-code-resolve P{n}` in the same or even a different session.
+    For deeper analysis, suggestions on solution approaches and then final problem resolution, use `/ase-code-resolve <id-prefix/>P{n}` in the same or even a different session.
     </ase-tpl-hint>
 
     You *MUST* not output anything else in this STEP 3,

package/plugin/skills/ase-code-analyze/help.md

@@ -10,6 +10,7 @@
     [`--performance`|`-p`]
     [`--security`|`-s`]
     [`--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`)]
+    [`--prefix`|`-P` *prefix*]
     *source-reference*
 
 ##  DESCRIPTION
@@ -38,6 +39,14 @@ severity* order `HIGH`, `MEDIUM`, `LOW`, `ACCEPTED` - keeping the
 `file`/`line` order within the same severity - and are renumbered
 contiguously as `P<n>`, so `P1` is the most severe problem.
 
+The `--prefix`|`-P` *prefix* option prefixes every reported problem id
+with *prefix* and a hyphen, so `P1` becomes `<prefix>-P1` and its
+persisted key becomes `ase-issue-<prefix>-P1`. The purge of stale
+results is narrowed to the same namespace accordingly, so analyses run
+under *distinct* prefixes coexist instead of overwriting each other.
+Without the option (the default), ids stay unprefixed and the purge
+covers the *entire* `ase-issue-*` space, including any prefixed results.
+
 The skill investigates the code base silently, reports each detected
 problem as a `PROBLEM` entry with severity (`LOW`, `MEDIUM`, `HIGH`) and
 inline file/line references (in the performance lens, each entry
@@ -83,6 +92,12 @@ Analyze a directory, reporting only `MEDIUM` and `HIGH` problems:
 ❯ /ase-code-analyze -S MEDIUM src/handlers/
 ```
 
+Analyze a directory under an own id namespace, yielding `auth-P1`, `auth-P2`, ...:
+
+```text
+❯ /ase-code-analyze --prefix auth src/auth/
+```
+
 ##  SEE ALSO
 
 [`ase-code-resolve`](../ase-code-resolve/help.md), [`ase-code-refactor`](../ase-code-refactor/help.md), [`ase-code-lint`](../ase-code-lint/help.md),

package/plugin/skills/ase-code-craft/SKILL.md

@@ -17,9 +17,9 @@ allowed-tools:
 @${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
-<skill name="ase-code-craft">
+<purpose name="ase-code-craft">
 Craft Source Code
-</skill>
+</purpose>
 
 <expand name="getopt"
     arg1="ase-code-craft"

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

@@ -0,0 +1,380 @@
+---
+name: ase-code-dissect
+argument-hint: "[--help|-h] [--max-parts|-m <count>] [--staged|-s] [--dry|-d] [--force|-f] [<dissect-hint>]"
+description: >
+    Dissect the current Git change set, treated as an epic, domain-wise
+    and logically into cohesive parts and materialize each part in its
+    own dedicated Git WorkTree. Use when the user calls to "dissect",
+    "split", "break up", or "decompose" a large change set into atomic,
+    separately committable parts.
+user-invocable: true
+disable-model-invocation: false
+effort: xhigh
+allowed-tools:
+    - "Bash(git *)"
+    - "Bash(rm -f *)"
+    - "Write"
+    - "Read"
+    - "Edit"
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
+
+<purpose name="ase-code-dissect">
+Dissect a Change Set
+</purpose>
+
+<expand name="getopt"
+    arg1="ase-code-dissect"
+    arg2="--max-parts|-m=8 --staged|-s --dry|-d --force|-f">
+    $ARGUMENTS
+</expand>
+
+<objective>
+*Dissect* the current Git change set, treated as an *epic*, domain-wise
+and logically into *cohesive parts*, and materialize every part in its
+own dedicated *Git WorkTree*, so each part can be reviewed and
+committed *atomically* and *independently*.
+</objective>
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-dissect.md
+
+Procedure
+---------
+
+<flow>
+
+1.  <step id="STEP 1: Determine Change Set and Hint">
+
+    1.  Determine the *dissection hint*: set
+        <dissect-hint><getopt-arguments/></dissect-hint>, with any
+        leading and trailing whitespace stripped. Additionally, inherit
+        the always existing <ase-project-id/> from the current context,
+        as it names the worktrees and branches of all derived parts.
+
+        <if condition="<dissect-hint/> is not empty">
+        Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ⇌ hint: **<dissect-hint/>**
+        </template>
+        </if>
+        <else>
+        No dissection hint was given, so the parts are derived from the
+        change set alone. Do not output anything.
+        </else>
+
+    2.  Determine the *repository root* by running the corresponding
+        command (taken exactly as given) and capturing its output into
+        <repo-root/>:
+
+        `git rev-parse --show-toplevel`
+
+    3.  Determine the *diff details* and the *diff statistics* by
+        running the corresponding commands (taken exactly as given) and
+        capturing their full outputs into <diff/> and <stat/>:
+
+        <if condition="<getopt-option-staged/> is equal `true`">
+        `git diff --cached HEAD`
+
+        `git diff --cached --numstat HEAD`
+        </if>
+        <else>
+        `git diff`
+
+        `git diff --numstat`
+        </else>
+
+    4.  <if condition="<getopt-option-staged/> is not equal `true`">
+        Additionally, *fold in the untracked files* -- they are part of
+        the working copy change set, but carry no diff of their own.
+        Determine them *read-only* by running the corresponding command
+        (taken exactly as given):
+
+        `git -C "<repo-root/>" -c core.quotepath=off ls-files --others --exclude-standard`
+
+        *Skip* every listed entry below the `.ase/` directory -- it
+        carries *ASE*'s own state and the worktrees created by this very
+        skill, and hence is never part of the user's change set.
+
+        Then, for *every* remaining listed file, capture its creation
+        diff by running the corresponding command (taken exactly as
+        given) and *append* its output to <diff/>:
+
+        `git -C "<repo-root/>" diff --no-index --binary /dev/null "<file/>"`
+
+        This command intentionally exits with a non-zero status,
+        because the two compared paths differ; treat this exit status
+        as *success*, not as an error. Judge the *outcome* by the
+        *output* instead: a run which emits *no* diff on standard output
+        but an `error:` or `fatal:` message (e.g. the entry is a *nested*
+        Git repository, which `git ls-files` reports as a directory) is a
+        *real* failure -- append nothing for that entry and only output
+        the following <template/>, then continue with the next file:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ⊘ untracked: `<file/>`, ▶ status: **not foldable into the change set**
+        </template>
+        </if>
+        <else>
+        Untracked files are *not* folded in under `--staged`/`-s`,
+        because they are by definition *not* part of the Git index. Do
+        not output anything.
+        </else>
+
+    5.  <if condition="<diff/> is empty">
+        Only output the following <template/> and then *STOP* immediately:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ▶ status: **no changes to dissect**
+        </template>
+        </if>
+
+    </step>
+
+2.  <step id="STEP 2: Dissect Change Set">
+
+    1.  *Derive the parts* of the epic:
+
+        <expand
+            name="dissect-derive"
+            arg1="ase-code-dissect"
+            arg2="<dissect-hint/>"
+            arg3="<ase-project-id/>"
+        >
+        the individual hunks of the captured <diff/>, weighted by the
+        line counts of <stat/> and -- for the folded-in untracked files,
+        which carry no <stat/> entry -- by their own diff line counts
+        </expand>
+
+        Additionally, try to keep *all* hunks of *one* file in the
+        *same* part, and split a file's hunks across parts *only* when
+        they are genuinely unrelated -- this keeps the per-part patches
+        applicable.
+
+        A *single* hunk is *atomic* here, so rule 3's splitting
+        permission does *not* apply to it: you *MUST NOT* break a hunk
+        into sub-hunks, because this would require re-computing its `@@`
+        header and hence destroy the byte-exactness the per-part
+        <patch/> depends on.
+
+    2.  *Report the parts*:
+
+        <expand name="dissect-report" arg1="<ase-project-id/>"></expand>
+
+    </step>
+
+3.  <step id="STEP 3: Detect Target Collisions"
+        condition="<getopt-option-dry/> is not equal `true`">
+
+    1.  Determine the *existing worktrees* and *existing branches* by
+        running the corresponding commands (taken exactly as given) and
+        capturing their outputs:
+
+        `git worktree list --porcelain`
+
+        `git branch --list`
+
+    2.  Set <collisions/> to all <part-id/> of <parts/> for which either
+        a worktree directory `<repo-root/>/.ase/worktree/<part-id/>` or
+        a branch `<part-id/>` already exists.
+
+    3.  <if condition="<collisions/> is not empty AND <getopt-option-force/> is not equal `true`">
+        Only output the following <template/> -- with <collisions/>
+        rendered as a comma-separated list of code spans -- and then
+        immediately *STOP* processing the entire current skill, leaving
+        *all* existing worktrees and branches untouched:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ⊘ collisions: <collisions/>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ✪ dissection: **<n/>** parts, ▶ status: **targets exist**
+        </template>
+
+        Directly *after* this <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">
+        Re-run `/ase-code-dissect --force` to remove and re-create the colliding worktrees and branches.
+        </ase-tpl-hint>
+        </if>
+
+    4.  <if condition="<collisions/> is not empty AND <getopt-option-force/> is equal `true`">
+        *Remove* every colliding target by running the corresponding
+        commands (taken exactly as given) per colliding <part-id/>, and
+        silently ignore the failure of an individual command when the
+        corresponding worktree or branch does not exist:
+
+        `git worktree remove --force "<repo-root/>/.ase/worktree/<part-id/>"`
+
+        `git worktree prune`
+
+        `git branch -D "<part-id/>"`
+        </if>
+
+    </step>
+
+4.  <step id="STEP 4: Materialize WorkTrees"
+        condition="<getopt-option-dry/> is not equal `true`">
+
+    You *MUST* *NEVER* mutate the *original* working copy in this step:
+    do *not* modify, stage, stash, revert, or commit anything outside of
+    the freshly created worktrees.
+
+    1.  Set <tmp-dir/> to the value of the `TMPDIR` environment variable
+        if it is known in the current session context, and to `/tmp`
+        otherwise. Do not output anything.
+
+    2.  For *every* part in <parts/>, in their derived order:
+
+        1.  Assemble <patch/> from the *verbatim* subset of <diff/>
+            assigned to this part: keep the complete `diff --git` file
+            headers and the complete `@@` hunk headers of the assigned
+            hunks, and change *nothing* inside them.
+
+            The captured <diff/> is *byte-exact* input and <patch/> stays
+            *byte-exact*, too, because `git apply` rejects even the
+            smallest deviation. You *MUST* therefore *NEVER* re-wrap a
+            line, re-indent a line, normalize or strip trailing
+            whitespace, drop the leading context/`+`/`-` marker column,
+            re-encode a character, or omit the trailing newline -- and
+            you *MUST* *NEVER* re-render any part of the diff as
+            Markdown, so no bullet marker and no inline code span is ever
+            introduced into <patch/>.
+
+        2.  Use the `Write` tool to write <patch/> to the patch file
+            `<tmp-dir/>/ase-dissect-<part-id/>.patch`.
+
+        3.  Create the worktree by running the corresponding command
+            (taken exactly as given), which creates the directory
+            *and* -- named after its last path component -- the branch
+            <part-id/> from `HEAD`. The `.ase` directory is usually
+            git-ignored, so the worktree itself never shows up as a
+            change:
+
+            `git worktree add "<repo-root/>/.ase/worktree/<part-id/>"`
+
+            <if condition="this command fails">
+            Only output the following <template/>, then *continue* with
+            the *next* part -- a single failing part *never* aborts the
+            remaining ones:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ◉ part: **<part-id/>**, ▶ status: **worktree failed to create**
+            </template>
+            </if>
+
+        4.  Apply the patch *inside* the freshly created worktree by
+            running the corresponding command (taken exactly as given):
+
+            `git -C "<repo-root/>/.ase/worktree/<part-id/>" apply --whitespace=nowarn "<tmp-dir/>/ase-dissect-<part-id/>.patch"`
+
+            <if condition="this command fails">
+            Only output the following <template/>, then *continue* with
+            the *next* part -- a single failing part *never* aborts the
+            remaining ones:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ◉ part: **<part-id/>**, ▶ status: **patch failed to apply**
+            </template>
+            </if>
+
+        5.  <if condition="a `CHANGELOG.md` file exists in the created worktree">
+            Add *one* new entry to the *first* (most recent) section of
+            that `CHANGELOG.md` *inside the worktree*, summarizing
+            *this part's* change set only, and strictly aligned with the
+            established style and conventions of the project (usually
+            `- <change-type/> [<artifact-kind/>]: <summary/>`).
+
+            The *existing* `CHANGELOG.md` is *changed*, never replaced:
+            you *MUST* use the `Read` tool to read it and the `Edit` tool
+            to insert the single new entry *in place*, and you *MUST*
+            *NEVER* use the `Write` tool on it, as this would drop the
+            entire remaining change history.
+
+            <if condition="the patch of this part already added an entry to that `CHANGELOG.md`">
+            The part's own change set already carries its `CHANGELOG.md`
+            entry, so you *MUST* *NOT* add a second one. Keep the entry
+            which came with the patch and, if it mentions changes which
+            landed in *other* parts, reduce it to *this* part's change
+            set only.
+            </if>
+            </if>
+            <else>
+            The project keeps no `CHANGELOG.md`, so nothing is added and
+            no `CHANGELOG.md` is created. Do not output anything.
+            </else>
+
+        6.  Leave the worktree *uncommitted*: do *not* run `git add` and
+            do *not* run `git commit`, so the user keeps full control
+            over the final commit of every part.
+
+        7.  Only output the following <template/>:
+
+            <template>
+            ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ◉ part: **<part-id/>**, ▶ status: **worktree created**
+            </template>
+
+    3.  *Clean up* the temporary patch files by running the
+        corresponding command (taken exactly as given) once per
+        <part-id/> of the *successfully* materialized <parts/>, and
+        silently ignore the failure of an individual command when the
+        corresponding patch file does not exist:
+
+        `rm -f "<tmp-dir/>/ase-dissect-<part-id/>.patch"`
+
+        The patch file of a *successful* part is a pure *intermediate*:
+        it was already consumed by `git apply` and its content is fully
+        preserved in the worktree, so it is removed. The patch file of a
+        part whose worktree or patch *failed* is *kept* instead, because
+        it is that part's only materialization and would otherwise be
+        lost. Do not output anything.
+
+    </step>
+
+5.  <step id="STEP 5: Report Result">
+
+    1.  <if condition="<getopt-option-dry/> is equal `true`">
+        Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ✪ dissection: **<n/>** parts, ▶ status: **dry-run -- no worktrees created**
+        </template>
+        </if>
+        <else>
+        Only output the following <template/>:
+
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-dissect**, ✪ dissection: **<n/>** parts, ▶ status: **change set dissected**
+        </template>
+        </else>
+
+    2.  Finally, give the closing hints by expanding the following
+        (which, depending on the configured <ase-guidance-level/>, may
+        each expand into nothing and hence emit no output at all):
+
+        <if condition="<getopt-option-dry/> is not equal `true`">
+        <ase-tpl-hint level="minimal">
+        The parts are uncommitted in `.ase/worktree/<id>` -- review and commit each of them separately, then remove them via `git worktree remove`.
+        </ase-tpl-hint>
+        </if>
+        <else>
+        <ase-tpl-hint level="minimal">
+        Re-run `/ase-code-dissect` without `--dry` to actually create the reported worktrees, optionally with a `<dissect-hint>` argument if the reported split is not the intended one.
+        </ase-tpl-hint>
+        </else>
+
+        <ase-tpl-hint level="normal">
+        Use `/ase-meta-diff` and `/ase-meta-review` inside a part's worktree to summarize and review it before committing.
+        </ase-tpl-hint>
+
+        <ase-tpl-hint level="verbose">
+        Use `/ase-code-dissect --staged` to dissect the staged changes only, `--max-parts <count>` to bound the number of parts, `--force` to re-create already existing worktrees, and a `<dissect-hint>` argument to steer the split.
+        </ase-tpl-hint>
+
+    </step>
+
+</flow>