@rse/ase 1.0.7 → 2.0.1

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

@@ -482,7 +482,7 @@ interface quality, quality attributes, and architecture governance.
     nothing and hence emit no output at all):
 
     <ase-tpl-hint level="minimal">
-    For deeper analysis, suggestions on solution approaches and then final source code changes, use `/ase-code-resolve <id-prefix/>P{n}` or `/ase-code-resolve <id-prefix/>T{n}`, or for a direct one-shot fix use `/ase-code-edit <id-prefix/>P{n}` or `/ase-code-edit <id-prefix/>T{n}`, in the same or even a different session.
+    For deeper analysis, suggestions on solution approaches and then final source code changes, use `/ase-task-edit <id-prefix/>P{n}` or `/ase-task-edit <id-prefix/>T{n}`, or for a direct one-shot fix use `/ase-code-edit <id-prefix/>P{n}` or `/ase-code-edit <id-prefix/>T{n}`, in the same or even a different session.
     </ase-tpl-hint>
 
     </step>

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

@@ -69,5 +69,5 @@ Analyze a module under its own id namespace, yielding `core-P1`, `core-T1`, ...:
 
 ##  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),
-[`ase-code-refactor`](../ase-code-refactor/help.md), [`ase-code-insight`](../ase-code-insight/help.md).
+[`ase-arch-discover`](../ase-arch-discover/help.md), [`ase-code-analyze`](../ase-code-analyze/help.md), [`ase-task-edit`](../ase-task-edit/help.md),
+[`ase-code-edit`](../ase-code-edit/help.md), [`ase-code-insight`](../ase-code-insight/help.md).

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

@@ -1,6 +1,6 @@
 ---
 name: ase-code-analyze
-argument-hint: "[--help|-h] [--performance|-p] [--security|-s] [--severity|-S=(LOW|MEDIUM|HIGH)] [--prefix|-P=<prefix>] <source-reference>"
+argument-hint: "[--help|-h] [--performance|-p] [--security|-s] [--severity|-S=(LOW|MEDIUM|HIGH)] [--prefix|-P=<prefix>] [--staged] [--unstaged] [<source-reference>]"
 description: >
     Analyze the source code for problems in either the logic and
     semantics and its related control flow, performance and efficiency,
@@ -11,6 +11,8 @@ effort: high
 allowed-tools:
     - "Agent"
     - "Glob"
+    - "Bash(git rev-parse *)"
+    - "Bash(git -C *)"
 ---
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@@ -23,7 +25,7 @@ Analyze Source Code
 
 <expand name="getopt"
     arg1="ase-code-analyze"
-    arg2="--performance|-p --security|-s --severity|-S=(LOW|MEDIUM|HIGH) --prefix|-P=">
+    arg2="--performance|-p --security|-s --severity|-S=(LOW|MEDIUM|HIGH) --prefix|-P= --staged --unstaged">
     $ARGUMENTS
 </expand>
 
@@ -59,8 +61,9 @@ problems in *performance* and *efficiency*, or problems in *security*.
     The project source artifacts are classified as a *black box*, so
     the user does *not* want them inspected or their problems surfaced.
     *Skip* the entire investigation and analysis: do *not* invoke any
-    `Glob` or `Agent` tool and do *not* read any source, only output
-    the following <template/> and then *SKIP* the remaining step STEP 3:
+    `Bash`, `Glob`, or `Agent` tool and do *not* read any source, only
+    output the following <template/> and then *SKIP* the remaining step
+    STEP 3:
 
     <template>
     <ase-tpl-bullet-normal/> **CODE ANALYSIS**: *suppressed* (`project.boxing` is `black`)
@@ -84,10 +87,58 @@ problems in *performance* and *efficiency*, or problems in *security*.
     `true`, set <lens>security</lens> if <getopt-option-security/> is
     equal `true`, and set <lens>logic</lens> otherwise.
 
+    <if condition="<getopt-option-staged/> is equal `true` or <getopt-option-unstaged/> is equal `true`">
+
+    Then *silently* restrict the analysis to the *changed* files of
+    the Git working copy. Set <changes>staged and unstaged</changes>
+    if both <getopt-option-staged/> and <getopt-option-unstaged/> are
+    equal `true`, set <changes>staged</changes> if only
+    <getopt-option-staged/> is equal `true`, and set
+    <changes>unstaged</changes> otherwise. Determine the *repository
+    root* by running the command `git rev-parse --show-toplevel`
+    (taken exactly as given) and capturing its output into
+    <repo-root/>. Then determine the changed files by running the
+    corresponding commands (taken exactly as given), each listing one
+    path relative to <repo-root/> per line, and collect all listed
+    paths, dropping duplicates:
+
+    <if condition="<getopt-option-staged/> is equal `true`">
+    `git -C "<repo-root/>" -c core.quotepath=off diff --cached --name-only --diff-filter=d`
+    </if>
+
+    <if condition="<getopt-option-unstaged/> is equal `true`">
+    `git -C "<repo-root/>" -c core.quotepath=off diff --name-only --diff-filter=d`
+
+    `git -C "<repo-root/>" -c core.quotepath=off ls-files --others --exclude-standard`
+    </if>
+
+    *Skip* every listed path below the `.ase/` directory (it carries
+    *ASE*'s own state) and every path which is not a source code file
+    (e.g. a binary file), and prefix every remaining path with
+    `<repo-root/>/`. If `<getopt-arguments/>` is not empty, keep only
+    those files which lie within the source code referenced by it,
+    expanding any directory or wildcard references with the `Glob`
+    tool. Set <sources/> to the resulting list of individual source
+    code files, preserving order.
+
+    If <sources/> is empty, only output the following <template/>
+    and then *SKIP* the rest of this STEP 2 and the remaining step
+    STEP 3:
+
+    <template>
+    <ase-tpl-bullet-normal/> **CODE ANALYSIS**: *no <changes/> source files to analyze*
+    </template>
+
+    </if>
+    <else>
+
     Then *silently* resolve `<getopt-arguments/>` to the list
     <sources/> of individual source code files, expanding any
-    directory or wildcard references with the `Glob` tool. Then
-    partition <sources/>, preserving order, into at most *eight*
+    directory or wildcard references with the `Glob` tool.
+
+    </else>
+
+    Then partition <sources/>, preserving order, into at most *eight*
     batches of roughly equal size (a single file yields a single
     batch), and invoke the following tool once per batch, emitting
     *all* invocations *in one single message* so they run in
@@ -117,7 +168,7 @@ problems in *performance* and *efficiency*, or problems in *security*.
     to that list.
 
     You *MUST* *NOT* output anything at all in this STEP 2 beyond the
-    `Glob` and `Agent` tool invocations.
+    `Bash`, `Glob`, and `Agent` tool invocations and the templates above.
 
     </step>
 
@@ -218,7 +269,7 @@ problems in *performance* and *efficiency*, or problems in *security*.
     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 <id-prefix/>P{n}`, or for a direct one-shot fix use `/ase-code-edit <id-prefix/>P{n}`, in the same or even a different session.
+    For deeper analysis, suggestions on solution approaches and then final problem resolution, use `/ase-task-edit <id-prefix/>P{n}`, or for a direct one-shot fix use `/ase-code-edit <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

@@ -11,7 +11,9 @@
     [`--security`|`-s`]
     [`--severity`|`-S`=(`LOW`|`MEDIUM`|`HIGH`)]
     [`--prefix`|`-P` *prefix*]
-    *source-reference*
+    [`--staged`]
+    [`--unstaged`]
+    [*source-reference*]
 
 ##  DESCRIPTION
 
@@ -47,19 +49,29 @@ 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 `--staged` option restricts the analysis to the source files with
+*staged* Git changes, and the `--unstaged` option restricts it to the
+source files with *unstaged* Git changes plus the *untracked* source
+files. Deleted files are skipped, and the files are analyzed in their
+current working copy state. With a *source-reference*, only the changed
+files within it are analyzed; without one, all changed files of the
+repository are analyzed. If no such file exists, nothing is analyzed.
+Both options can be combined to analyze the source files with *any*
+uncommitted Git changes.
+
 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
 additionally carries an *evidence* and a *trade-off* line), and persists
 results in the `ase` MCP key/value store as `ase-issue-P<n>` entries so
-they can later be resolved via `ase-code-resolve P<n>` or directly
+they can later be planned via `ase-task-edit P<n>` or directly
 fixed via `ase-code-edit P<n>`.
 
 ##  ARGUMENTS
 
 -   *source-reference*:
     A file, directory, function, or other reference to the source code
-    to analyze.
+    to analyze. Optional only under `--staged` or `--unstaged`.
 
 ##  SCENARIOS
 
@@ -68,6 +80,7 @@ fixed via `ase-code-edit P<n>`.
 -   You want performance and efficiency opportunities surfaced
 -   You want a security-focused inspection of your code
 -   You want problems persisted as issue ids like `P1` for later resolving
+-   You want only your staged or unstaged changes analyzed before committing
 
 ##  EXAMPLES
 
@@ -107,7 +120,19 @@ Analyze a directory under its own id namespace, yielding `auth-P1`, `auth-P2`, .
 ❯ /ase-code-analyze --prefix auth src/auth/
 ```
 
+Analyze only the source files with staged Git changes:
+
+```text
+❯ /ase-code-analyze --staged
+```
+
+Analyze only the unstaged and untracked source files below a directory:
+
+```text
+❯ /ase-code-analyze --unstaged src/handlers/
+```
+
 ##  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),
+[`ase-task-edit`](../ase-task-edit/help.md), [`ase-code-edit`](../ase-code-edit/help.md), [`ase-code-lint`](../ase-code-lint/help.md),
 [`ase-code-explain`](../ase-code-explain/help.md), [`ase-arch-analyze`](../ase-arch-analyze/help.md).

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

@@ -1,6 +1,6 @@
 ---
 name: ase-code-edit
-argument-hint: "[--help|-h] [--mode|-m auto|craft|refactor|resolve] [--grill|-g] [--grill-rounds|-r <n>] [--verify|-v] [--worktree|-w] [--loop|-l] [<query>|<issue-id>]"
+argument-hint: "[--help|-h] [--mode|-m auto|craft|refactor|resolve] [--approach|-a] [--grill|-g] [--grill-rounds|-r <n>] [--grill-until|-u MUST|SHOULD|MAY] [--grill-perspective|-p <perspective>] [--grill-ground|-G] [--verify|-v] [--worktree|-w <name>[:<branch>]] [--loop|-l] [<query>|<issue-id>]"
 description: >
     Edit Source Code: Use when the user wants to "edit" the code base in
     one shot from a query or a bare analyzer issue id like "P1", fusing
@@ -22,7 +22,7 @@ Edit Source Code
 
 <expand name="getopt"
     arg1="ase-code-edit"
-    arg2="--mode|-m=(auto|craft|refactor|resolve) --grill|-g --grill-rounds|-r=1 --verify|-v --worktree|-w --loop|-l">
+    arg2="--mode|-m=(auto|craft|refactor|resolve) --approach|-a --grill|-g --grill-rounds|-r=1 --grill-until|-u=(MUST|SHOULD|MAY) --grill-perspective|-p= --grill-ground|-G --verify|-v --worktree|-w= --loop|-l">
     $ARGUMENTS
 </expand>
 
@@ -34,6 +34,8 @@ resolving in one shot -- through the states *querying*, *discovering*,
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-tenets.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-common-grill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-changeset.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-common-approach.md
 
 Procedure
 ---------
@@ -77,6 +79,12 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
         ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ ERROR: invalid `--grill-rounds` value: **<getopt-option-grill-rounds/>**
         </template>
 
+    3.  Resolve a potentially misparsed former boolean `--worktree`
+        option:
+
+        <expand name="changeset-ambiguity"
+            arg1="✪ skill: **ase-code-edit**"></expand>
+
 2.  **Iterate:**
 
     Perform the states (1) *querying*, (2) *discovering*, (3) *grilling*,
@@ -157,10 +165,32 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
 
 4.  **State: discovering:**
 
-    Check the existing source files for all code which is related to
-    <todo-what/> and <todo-how/>, and check the architecture of the
-    existing code base to understand the overall structures and
-    dynamics. Do not output anything in this state.
+    1.  <if condition="<getopt-option-worktree/> is not empty and <worktree-dir/> is empty">
+
+        One *single* worktree serves the whole skill run: it is
+        prepared *once* before the first discovery, so discovering,
+        grilling, and implementing all operate on the *same* tree, and
+        all further `--loop` iterations land in it, too.
+
+        <expand name="changeset-context"
+            arg1="<getopt-option-worktree/>"
+            arg2="✪ skill: **ase-code-edit**"
+            arg3="true"
+            arg4="true"></expand>
+
+        Set <worktree-dir><context-dir/></worktree-dir>. Do not output
+        anything.
+
+        </if>
+
+    2.  <if condition="<worktree-dir/> is not empty">
+        <expand name="changeset-land" arg1="<worktree-dir/>"></expand>
+        </if>
+
+    3.  Check the existing source files for all code which is related to
+        <todo-what/> and <todo-how/>, and check the architecture of the
+        existing code base to understand the overall structures and
+        dynamics. Do not output anything.
 
 5.  **State: grilling:**
 
@@ -170,10 +200,21 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
 
     1.  Understand what "grilling" is about:
 
-        <expand name="grill-understanding" arg1="the edit query in <todo-what/> and <todo-how/>"></expand>
+        <expand name="grill-understanding"
+            arg1="the edit query in <todo-what/> and <todo-how/>"
+            arg2="<getopt-option-grill-perspective/>"
+            arg3="<getopt-option-grill-ground/>"></expand>
 
-    2.  Perform <getopt-option-grill-rounds/> grilling *rounds*,
-        numbered <m/> (1-<getopt-option-grill-rounds/>).
+    2.  Ground the grilling:
+
+        <expand name="grill-ground"
+            arg1="the edit query in <todo-what/> and <todo-how/>"
+            arg2="<worktree-dir/>"></expand>
+
+    3.  Perform *at most* <getopt-option-grill-rounds/> grilling
+        *rounds*, numbered <m/> (1-<getopt-option-grill-rounds/>) --
+        the round count is a *maximum* only, as every round can
+        *stop* the grilling *early* in its item 2 below.
 
         For each round:
 
@@ -181,7 +222,8 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
 
             Explicitly start *from scratch* from *only* the current
             <todo-what/> and <todo-how/> and *forget* all information
-            gathered in previous rounds. Set <round-id/> to
+            gathered in previous rounds -- except the grounding facts
+            <grill-facts/>. Set <round-id/> to
             `GRILLING ROUND <m/>/<getopt-option-grill-rounds/>` if
             <getopt-option-grill-rounds/> is greater than 1, or to
             `GRILLING` otherwise (a single round needs no round
@@ -189,82 +231,23 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
 
         2.  DETERMINE QUESTIONS:
 
-            Determine the questions, comprised of a round-local id
-            <question-N-id/> of `Q<N/>` -- where <N/> restarts at `1`
-            in *every* round, independent of the numbering of previous
-            rounds --, and a very brief but precise question text
-            <question-N-text/>. Each question is chosen to
-            resolve the open points related to the above understanding
-            of grilling, by focusing on the mentioned *Focus Areas*.
-
-            For <question-N-text/> use the format `Shall...?` for
-            questions of focus area `DOMAIN` and `INTERFACE`, the format
-            `Should...?` for questions of focus area `ARCHITECTURE`,
-            and the format `May...?` for questions of focus area
-            `IMPLEMENTATION`.
-
-            In every <question-N-text/>, encode all *literal aspects*
-            -- file and directory paths, identifiers, symbols, types,
-            commands, options, configuration keys, and literal values --
-            with backticks.
-
-            Keep every <question-N-text/> at most *200 characters* long
-            -- compact the text until it fits --, as a longer question
-            overflows its table cell and silently degrades the entire
-            table into a plain text rendering.
-
-        3.  DETERMINE CONTEXT:
-
-            For each question, determine its focus area
-            <context-N-focus/> from the mentioned *Focus Areas*, a 1-3
-            word hint <context-N-topic/>, describing what the question
-            is about, and a <context-N-severity/>, describing how
-            important this question is.
-
-            Set <context-N-id/> to `DOM` for <context-N-focus/> of
-            `DOMAIN`, `IFC` for <context-N-focus/> of `INTERFACE`, `ARC`
-            for <context-N-focus/> of `ARCHITECTURE`, and `IMP` for
-            <context-N-focus/> of `IMPLEMENTATION`.
-
-        4.  SORT QUESTIONS:
-
-            Finally, *sort* the questions by descending focus area
-            order -- first all `DOMAIN`, then all `INTERFACE`, then all
-            `ARCHITECTURE`, and then all `IMPLEMENTATION` ones -- and
-            renumber <N/> according to this order, starting at `1`.
-            Truncate the list after a maximum of 10 questions and set
-            <n/> to the number of remaining questions. Do not output
-            anything.
-
-            Finally, assemble the <question-N/> out of
-            `**<question-N-id/>** ▶ **<context-N-id/>** ▷
-            **<context-N-topic/>**: <question-N-text/>`.
-
-        5.  DETERMINE ANSWERS:
-
-            For all remaining <question-N/>, check the code base and
-            your world knowledge to find *two to three* grounded answer
-            alternatives <answer-N-K/> with a question-local id
-            <answer-N-K-id/> of `A<K/>` -- where <K/> restarts at `1`
-            for *every* question, independent of the numbering of other
-            questions --, a 1-3 word label <answer-N-K-label/>, and
-            an ultra brief description <answer-N-K-description/> of
-            at most *10 words*. For the answer which reflects the
-            current <todo-what/>/<todo-how/> understanding, append
-            ` ⚑` to its <answer-N-K-label/>.
-
-            Assemble an <answer-N/> out of `**<answer-N-1-id/>**
-            ▶ **<answer-N-1-label/>**: <answer-N-1-description/>,
-            **<answer-N-2-id/>** ▶ **<answer-N-2-label/>**:
-            <answer-N-2-description/>[, ...]`.
-
-            Keep every assembled <answer-N/> at most *240 characters*
-            long -- drop the least relevant alternative and compact the
-            descriptions until it fits -- as a longer answer overflows
-            its table cell and silently degrades the entire table into a
-            plain text rendering.
-
-        6.  INTERACTIVE DIALOG:
+            <expand name="grill-questions"
+                arg1="<getopt-option-grill-until/>"
+                arg2="✪ skill: **ase-code-edit**"
+                arg3="file and directory paths, identifiers, symbols, types, commands, options, configuration keys, and literal values"
+                arg4="the code base"
+                arg5="">
+                <if condition="<getopt-option-verify/> is not equal `true`">
+                Raise *no* questions at all of focus area `REGRESSION`
+                or `CONFIRMATION`, as without `--verify` no verification
+                takes place which could honor their decisions.
+                </if></expand>
+
+            If <grill-stop/> is `true`, skip the remaining items of
+            this round and all remaining rounds, and continue with
+            the *implementing* state.
+
+        3.  INTERACTIVE DIALOG:
 
             In the following, you *MUST* *NOT* use your built-in
             <user-dialog-tool/> tool! Instead, you *MUST* just show a
@@ -274,8 +257,8 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
             `SKIP GRILLING` and `STOP SKILL`, dispatched as follows:
 
             -   If a <result/> is `SKIP GRILLING` or `CANCEL`, ask no
-                further questions, continue with item 7 below (merging
-                the answers gathered so far), and after item 8 skip all
+                further questions, continue with item 4 below (merging
+                the answers gathered so far), and after item 5 skip all
                 remaining rounds and continue with the *implementing*
                 state.
 
@@ -287,54 +270,31 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
                 ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ status: **editing stopped**
                 </template>
 
-            1.  Output only the following <template/> -- it lists *all*
-                questions of the round up-front, one table row per
-                aspect, so the subsequent dialog only has to ask for the
-                combined answer. Align all column edges of the table.
-
-                In every table cell you *MUST* escape each literal pipe
-                character outside a code span as `\|` and you *MUST*
-                open *and* close every backtick code span within the
-                *same* cell -- an unescaped pipe or an unbalanced
-                backtick run splits the cell and silently degrades the
-                entire table into a plain text rendering:
-
-                <template>
-                ⧉ **ASE**: <round-id/>: *Relentless Interviewing Until Clarity*
-
-                | QUESTION      | ANSWERS     |
-                | ------------- | ----------- |
-                | <question-1/> | <answer-1/> |
-                | <question-2/> | <answer-2/> |
-                | [...]         | [...]       |
-
-                Legend: **DOM**: Domain (MUST), **IFC**: Interface (MUST), **ARC**: Architecture (SHOULD), **IMP**: Implementation (MAY)
-                        **Qn**: round-local question id, **An**: question-local answer id, ⚑: current decision state
-                </template>
+            Show a custom dialog. Its only answer options are the
+            two fixed ones, so the user normally answers all aspects in
+            *one* free-text reply:
 
-            2.  Show a custom dialog. Its only answer options are the
-                two fixed ones, so the user normally answers all aspects in
-                *one* free-text reply:
-
-                <expand name="custom-dialog" arg1="--other">
-                    <round-id/>: What is your (combined) answer to all (or a subset) of the above questions? (keywords or `Qn:An` references are sufficient)
-                    SKIP GRILLING: skip all remaining grilling and continue with the implementation
-                    STOP SKILL: stop the entire skill immediately
-                </expand>
+            <expand name="custom-dialog" arg1="--other">
+                <round-id/>: What is your (combined) answer to all (or a subset) of the above questions? (keywords or `nX` short responses are sufficient)
+                SKIP GRILLING: skip all remaining grilling and continue with the implementation
+                STOP SKILL: stop the entire skill immediately
+            </expand>
 
-                Dispatch `SKIP GRILLING`, `STOP SKILL`, and `CANCEL` as
-                defined above. Otherwise, strip any leading `OTHER: `
-                prefix from <result/> and treat the remainder as the
-                combined free-text answers to all questions of the
-                round.
+            Dispatch `SKIP GRILLING`, `STOP SKILL`, and `CANCEL` as
+            defined above. Otherwise, strip any leading `OTHER: `
+            prefix from <result/> and treat the remainder as the
+            combined free-text answers to all questions of the
+            round.
 
-        7.  MERGE ANSWERS INTO TODO:
+        4.  MERGE ANSWERS INTO TODO:
 
             Merge all gathered answers in <result/> of the round -- the
             combined reply -- *exclusively* back into <todo-what/> and
             <todo-how/>. Do not output anything.
 
-        8.  SHOW CURRENT TODO:
+            <expand name="grill-short-responses"></expand>
+
+        5.  SHOW UPDATED TODO:
 
             Set <round-suffix/> to
             ` round <m/>/<getopt-option-grill-rounds/>` if
@@ -370,58 +330,30 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
         in the following creation and updating of code. Do not output
         anything.
 
-    2.  <if condition="<getopt-option-worktree/> is equal `true` and <worktree-dir/> is empty">
-
-        One *single* worktree serves the whole skill run: it is created
-        *once* before the first change set is applied, and all further
-        `--loop` iterations land in it, too.
-
-        1.  Set <worktree-name/> to a unique name, derived from
-            <todo-what/>, which consists of two lower-case words
-            concatenated with a `-` character. Do not output anything.
-
-        2.  Determine the *worktree directory* by calling the
-            `ase_worktree_path(id: "<worktree-name/>", create: true)`
-            tool of the `ase` MCP server and capturing its output into
-            <worktree-dir/>. You *MUST* *NEVER* assemble this path
-            yourself. If this tool call fails, only output the following
-            <template/> and then immediately *STOP* processing the
-            entire current skill, leaving the working copy *untouched*:
-
-            <template>
-            ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ ERROR: no Git repository or unsafe worktree directory -- cannot create worktree
-            </template>
+    2.  <if condition="<getopt-option-approach/> is equal `true`">
 
-        3.  Determine the *existing worktrees* and *existing branches*
-            by running the commands `git worktree list --porcelain` and
-            `git branch --list` (taken exactly as given) and capturing
-            their outputs. If the worktree directory <worktree-dir/> or
-            the branch <worktree-name/> already exists, only output the
-            following <template/> and then immediately *STOP* processing
-            the entire current skill, leaving the existing worktree, its
-            branch, and the working copy *untouched*:
+        Set <approach-kind/> to `crafting`, `refactoring`, or
+        `resolution` for the <task-kind/> `CRAFTING`, `REFACTORING`, or
+        `RESOLVING` correspondingly, and determine the overall approach
+        of the edit, based on <todo-what/> and <todo-how/> plus the
+        information gathered in the *discovering* state:
 
-            <template>
-            ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ ERROR: worktree or branch **<worktree-name/>** already exists
-            </template>
+        <expand name="approach-select"
+            arg1="<approach-kind/>"
+            arg2="✪ skill: **ase-code-edit**"></expand>
 
-        4.  Create the worktree by running the command
-            `git worktree add "<worktree-dir/>"` (taken exactly as
-            given), which creates the directory *and* -- named after its
-            last path component -- the branch <worktree-name/> from
-            `HEAD`. If this command fails, only output the following
-            <template/> and then immediately *STOP* processing the
-            entire current skill, leaving the working copy *untouched*:
+        If <chosen-approach/> is empty, only output the following <template/>
+        and then immediately *STOP* processing the entire current skill:
 
-            <template>
-            ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ ERROR: worktree **<worktree-name/>** failed to create
-            </template>
+        <template>
+        ⧉ **ASE**: ✪ skill: **ase-code-edit**, ▶ status: **editing stopped**
+        </template>
 
-        5.  Only output the following <template/>:
+        Otherwise, merge <chosen-approach/> *exclusively* into <todo-how/>,
+        where the chosen approach overrides any conflicting
+        implementation detail, and expand the following:
 
-            <template>
-            ⧉ **ASE**: ✪ skill: **ase-code-edit**, ◉ worktree: **.ase/worktree/<worktree-name/>**, ▶ status: **worktree created**
-            </template>
+        <expand name="todo-box" arg1="current state (after approaching)"></expand>
 
         </if>
 
@@ -432,13 +364,7 @@ empty <todo-what/> or <todo-how/> renders as `(none)`:
         make an appropriate entry there, too.
 
         <if condition="<worktree-dir/> is not empty">
-        The change set *MUST* land *exclusively inside* the worktree
-        <worktree-dir/>: resolve *every* file path relative to
-        <worktree-dir/> instead of the original working copy. You *MUST*
-        *NEVER* modify, stage, stash, revert, or commit anything
-        *outside* of this worktree. 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.
+        <expand name="changeset-land" arg1="<worktree-dir/>"></expand>
         </if>
 
     4.  <if condition="<issue-id/> is not empty">