@rse/ase 0.9.51 → 0.9.52

package/dst/ase-task.js

@@ -451,7 +451,8 @@ export class TaskMCP {
         mcp.registerTool("ase_task_save", {
             title: "ASE task save",
             description: "Persist a task as `text` under `id`. " +
-                "Overwrites any existing task for the same `id`.",
+                "Overwrites any existing task for the same `id`. " +
+                "Returns the persisted task as `text`, prepared for improved rendering.",
             inputSchema: {
                 id: z.string()
                     .describe("task identifier (allowed characters: A-Z, a-z, 0-9, '_', '-')"),
@@ -461,8 +462,12 @@ export class TaskMCP {
         }, async (args) => {
             try {
                 Task.save(this.log, args.id, args.text);
+                /*  return the prepared content, so a caller reusing the
+                    just-saved plan instead of re-loading it still receives
+                    the rendering-prepared variant  */
+                const text = Markdown.prepare(args.text);
                 return {
-                    content: [{ type: "text", text: `OK: saved task "${args.id}"` }]
+                    content: [{ type: "text", text }]
                 };
             }
             catch (err) {

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.51",
+    "version":                              "0.9.52",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -23,14 +23,14 @@
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
-        "globals":                          "17.7.0",
+        "globals":                          "17.8.0",
         "typescript":                       "6.0.3",
 
         "@rse/stx":                         "1.1.6",
         "nodemon":                          "3.1.14",
         "shx":                              "0.4.0",
 
-        "@types/node":                      "26.1.1",
+        "@types/node":                      "26.1.2",
         "@types/luxon":                     "3.7.2",
         "@types/which":                     "3.0.4",
         "@types/update-notifier":           "6.0.8",
@@ -42,18 +42,18 @@
     },
     "dependencies": {
         "commander":                        "15.0.0",
-        "@dotenvx/dotenvx":                 "2.18.0",
+        "@dotenvx/dotenvx":                 "2.19.1",
         "yaml":                             "2.9.0",
         "valibot":                          "1.4.2",
-        "execa":                            "10.0.0",
+        "execa":                            "10.0.1",
         "mkdirp":                           "3.0.1",
         "@hapi/hapi":                       "21.4.10",
         "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
-        "chalk":                            "5.6.2",
+        "chalk":                            "6.0.0",
         "pretty-ms":                        "9.3.0",
         "luxon":                            "3.7.2",
-        "@modelcontextprotocol/sdk":        "1.29.0",
+        "@modelcontextprotocol/sdk":        "1.30.0",
         "json-asty":                        "1.3.4",
         "zod":                              "4.4.3",
         "which":                            "7.0.0",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.51",
+    "version":     "0.9.52",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.51",
+    "version":     "0.9.52",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.51",
+    "version":     "0.9.52",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/etc/stx.conf

@@ -12,9 +12,9 @@ lint
 #   [plugin] build project
 build : lint
     (   for name in $(cd skills; ls -1 | grep -v ase-help-intent | sort); do
-            echo "<skill name=\"$name\">"
+            echo "<purpose name=\"$name\">"
             cat skills/$name/help.md | sed -e '/^##  SEE ALSO/,$d'
-            echo "</skill>"
+            echo "</purpose>"
         done
     ) >skills/ase-help-intent/data.md
 

package/plugin/meta/ase-common-dissect.md

@@ -0,0 +1,110 @@
+
+Dissect Skill Common Steps
+==========================
+
+<define name="dissect-derive">
+
+*Dissect* <content/> into *cohesive parts* by strictly honoring the
+following ruleset:
+
+1.  *Separate domain-wise and logically*: every part *MUST* be a
+    *self-contained* unit of work with a *single*, coherent purpose (one
+    domain, one concern, one logical change), so it can be implemented,
+    reviewed, and committed entirely *on its own*. A *technical* split
+    -- one part per file, per directory, per file type, or per technical
+    layer -- is usually *not* the obvious and intended one: files are
+    merely *where* the change lands, while a part is defined by *what*
+    it achieves. Cut along the *semantics* first, and let a file-wise
+    boundary result only when it *coincides* with a domain boundary.
+
+2.  *Bound the part count*: derive at least *2* and at most
+    *<getopt-option-max-parts/>* parts. Prefer *fewer* and *larger*
+    cohesive parts over *many* and *tiny* ones.
+
+3.  *Assign totally and disjointly*: *every* input element of the epic
+    *MUST* be assigned to *exactly one* part -- no input element is
+    dropped, and no input element occurs in two parts. An input element
+    which itself spans *multiple* domains or concerns *MAY* be *split*
+    into two or more *sub-elements*, which are then assigned like
+    ordinary input elements, provided the sub-elements *together* cover
+    the original element *completely*, *never* overlap, and each one
+    stays *self-contained* in the input form the calling skill defines.
+    Split *only* when rule 1 forces it: an input element whose content
+    fits a *single* part stays *unsplit*.
+
+4.  *Keep mutually dependent elements together*: input elements which
+    only make sense *together* -- they reference each other, one is the
+    precondition of the other, or splitting them would leave a part
+    broken -- *MUST* land in the *same* part.
+
+5.  *Never invent*: parts are formed *exclusively* from the input
+    elements of the epic. Do *not* add scope, do *not* re-interpret the
+    input elements, and do *not* re-word them beyond what a part-local
+    summary requires.
+
+6.  *Slug and identify every part*: per part derive a <feature-slug/>
+    from its scope, matching the regexp `^[a-z][a-z0-9-]{0,23}$` and
+    *unique* across all parts, and then set
+    <part-id><arg3/>-<feature-slug/></part-id>, where <arg3/> is the
+    *id prefix* the calling skill passed in.
+
+7.  *Order for implementation*: order the parts so that a part *never*
+    depends on a later one, and number them consecutively as <part-no/>,
+    starting at `1`.
+
+8.  *Honor the dissection hint*:
+    <if condition="<arg2/> is not empty">
+    Set <hint><arg2/></hint>. The user explicitly told *how* the epic
+    should be split -- e.g. which input elements belong together, along
+    which axis to cut, or how many parts to aim at -- so you *MUST*
+    follow this <hint/> as closely as possible and let it *override* the
+    default grouping of rule 1. It *MUST NOT* override the rules 2-7,
+    though: the part count stays bounded, the assignment stays total and
+    disjoint, mutually dependent elements stay together, nothing is
+    invented, every part stays uniquely slugged, and the order stays
+    dependency-free. If the <hint/> conflicts with one of these rules,
+    honor the rule and follow the <hint/> only as far as the rule
+    permits.
+    </if>
+    <else>
+    No dissection hint was given, so the grouping follows the rules 1-7
+    alone. Do not output anything.
+    </else>
+
+Per part, additionally derive an *ultra brief* <scope/> (*what* the part
+covers) and an *ultra brief* <rationale/> (*why* exactly these input
+elements form *one* cohesive part). Store the resulting parts in
+<parts/> and their number in <n/>.
+
+<if condition="fewer than 2 cohesive parts exist">
+The epic is *not* dissectable, because it carries a *single* cohesive
+purpose (or too few input elements) and splitting it would only produce
+artificial fragments. Only output the following <template/> and then
+immediately *STOP* processing the entire current skill:
+
+<template>
+⧉ **ASE**: ✪ skill: **<arg1/>**, ▶ status: **epic not dissectable**
+</template>
+</if>
+
+</define>
+
+<define name="dissect-report">
+
+Report the derived <parts/> with the following <template/>, emitting
+*one* table row per part in <parts/>, in their derived order. Keep
+<scope/> and <rationale/> each to *one* ultra brief sentence, align all
+column edges of the table, and do *not* output any further explanation:
+
+<template>
+<ase-tpl-head title="DISSECTION" subtitle="<arg1/>">
+
+| Part            | Id           | Scope    | Rationale    |
+| --------------- | ------------ | -------- | ------------ |
+| **P<part-no/>** | `<part-id/>` | <scope/> | <rationale/> |
+| [...]           | [...]        | [...]    | [...]        |
+
+<ase-tpl-foot title="DISSECTION" subtitle="<arg1/>">
+</template>
+
+</define>

package/plugin/meta/ase-common-task.md

@@ -65,9 +65,11 @@ Task Skill Common Steps
     *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
+    Set <text/> to the `text` *output* field of the most recent
+    `ase_task_save(id: '<ase-task-id/>', ...)` tool call -- this is
+    the rendering-prepared plan content and *MUST NOT* be confused
+    with the `text` *argument* passed into that call -- *without*
+    calling `ase_task_load` again. Set <status>plan
     reused</status>. Do not output anything.
 </if>
 <else>

package/plugin/meta/ase-control.md

@@ -95,3 +95,56 @@ Control Flow Constructs
     is finished and no further repetitions are performed. This construct
     is expanded into nothing. Do not output anything.
 
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <agent <attr/>="<value/>" [...]><agent-body/></agent>:
+
+    This specifies the *invocation* of a *sub-agent* through the
+    `Agent` tool. Every XML attribute is passed *verbatim* as the
+    identically named parameter of the `Agent` tool (e.g. `description`,
+    `subagent_type`, `run_in_background`, `isolation`, `model`), and
+    <agent-body/> is passed as its `prompt` parameter.
+
+    The *sole exception* is the *reserved* attribute `result="<var/>"`,
+    which is *not* passed on but instead *binds* the result returned
+    by the sub-agent to the placeholder `<<var/>/>`. This construct is
+    expanded to the result returned by the sub-agent if `result` is
+    *absent*, or into nothing if `result` is *present*. Do not output
+    anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <agent-consolidation [group=<agent-group/>]/>
+
+    This specifies the merging of all the Git WorkTrees created by the
+    <agent/> calls with either are identified with the unique group
+    <agent-group/> or all <agent/> calls in the last <parallel/> section
+    of the context. After merging a single Git WorkTree, remove the Git
+    WorkTree.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <skill name="<id/>" [args="<args/>"] [result="<var/>"]/>:
+
+    This specifies the *invocation* of another *skill* through the
+    `Skill` tool, with its `skill` parameter set to <id/> and its `args`
+    parameter set to <args/> (or to the empty string if the `args`
+    attribute is absent).
+
+    The *reserved* attribute `result="<var/>"` *binds* the result
+    returned by the skill to the placeholder `<<var/>/>`, exactly
+    as for <agent/>. This construct is *always* *self-closing*: a
+    *body-bearing* `<skill>` element is *never* an invocation. This
+    construct is expanded to the result returned by the skill if
+    `result` is *absent*, or into nothing if `result` is *present*. Do
+    not output anything else.
+
+-   *IMPORTANT*: You *MUST* honor the following control flow construct:
+    <parallel><parallel-body/></parallel>:
+
+    This specifies a <parallel-body/> whose <agent/> and <skill/>
+    invocations are *all* dispatched *concurrently*: you *MUST* emit
+    them *in one single message* instead of one per turn, and this
+    construct is finished only once *all* of them have returned. If two
+    or more of these invocations bind the *same* `result` name, the
+    corresponding placeholder carries an *array* of their results, in
+    the order of their occurrence in <parallel-body/>. This construct is
+    expanded to its <parallel-body/>. Do not output anything else.
+

package/plugin/meta/ase-format-task.md

@@ -70,3 +70,9 @@ You *MUST* honor the following hints on this *task* format:
     after about 100 characters per line for better subsequent
     manual editing.
 
+-   You *MUST* *NEVER* break a line *inside* an inline code span
+    <template>`<code/>`</template>, as a code span split across two
+    lines renders badly. Instead, break the line *before* its opening
+    backtick or *after* its closing backtick, even if this means
+    breaking the line noticeably earlier than after 100 characters.
+

package/plugin/meta/ase-skill.md

@@ -209,18 +209,18 @@ MCP Tool Calls
 Skill Identification
 --------------------
 
--   *IMPORTANT*: Set <skill></skill> (set to empty)
+-   *IMPORTANT*: Set <purpose></purpose> (set to empty)
     and <skill-name></skill-name> (set name to empty).
 
-    In case <skill/> later becomes *not* empty by defining it as <skill
-    name="<name/>"><body/></skill>, set <skill-name><name/></skill-name>
-    (set skill name to name), and then (but only if ((`$1` is *NOT* equal
-    to `-h` or `--help`) *AND* (<ase-guidance-level/> is equal to `normal`
-    or `verbose`))) you *MUST* once output the following output
-    <template/>:
+    In case <purpose/> later becomes *not* empty by defining it as
+    <purpose name="<name/>"><body/></purpose>, set
+    <skill-name><name/></skill-name> (set skill name to name), and then
+    (but only if ((`$1` is *NOT* equal to `-h` or `--help`) *AND*
+    (<ase-guidance-level/> is equal to `normal` or `verbose`))) you *MUST*
+    once output the following output <template/>:
 
     <template>
-    ⧉ **ASE**: ✪ skill: **<skill-name/>**, ✦ purpose: **<skill/>**, ▶ status: **skill started**
+    ⧉ **ASE**: ✪ skill: **<skill-name/>**, ✦ purpose: **<purpose/>**, ▶ status: **skill started**
     </template>
 
     Later (but only if ((`$1` is *NOT* equal to `-h` or `--help`) *AND*

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.51",
+    "version":                              "0.9.52",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -16,7 +16,7 @@
     "devDependencies": {
         "@rse/stx":                         "1.1.6",
         "markdownlint":                     "0.41.1",
-        "markdownlint-cli2":                "0.23.1",
+        "markdownlint-cli2":                "0.23.2",
         "eslint":                           "10.8.0",
         "@eslint/markdown":                 "8.0.3",
         "eslint-markdown":                  "0.12.1"

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

@@ -102,11 +102,13 @@ allowed-tools:
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
-<skill name="ase-arch-analyze">
+<purpose name="ase-arch-analyze">
 Review Software Architecture
-</skill>
+</purpose>
 
-<expand name="getopt" arg1="ase-arch-analyze">
+<expand name="getopt"
+    arg1="ase-arch-analyze"
+    arg2="--prefix|-P=">
     $ARGUMENTS
 </expand>
 
@@ -343,6 +345,14 @@ interface quality, quality attributes, and architecture governance.
     </step>
 
 3.  <step id="STEP 3: Reconcile and Show Results">
+    Before reporting, determine the *finding 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` and `TRADEOFF` 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, classify every finding into one of three
     categories:
 
@@ -378,7 +388,7 @@ interface quality, quality attributes, and architecture governance.
     Report each unpaired finding with the following <template/>:
 
     <template>
-    <ase-tpl-bullet-signal/> **PROBLEM** P<n/> (Severity: <severity/>, Aspect: <aspect-id/>): **<title/>**
+    <ase-tpl-bullet-signal/> **PROBLEM** <id-prefix/>P<n/> (Severity: <severity/>, Aspect: <aspect-id/>): **<title/>**
 
     <description/>
     </template>
@@ -386,7 +396,7 @@ interface quality, quality attributes, and architecture governance.
     Report each paired or clustered finding with the following <template/>:
 
     <template>
-    <ase-tpl-bullet-normal/> **TRADEOFF** T<n/> (Severity: <severity/>): **<title/>**
+    <ase-tpl-bullet-normal/> **TRADEOFF** <id-prefix/>T<n/> (Severity: <severity/>): **<title/>**
 
     - *Focal aspect*: <focal-aspect/> - <focal-state/>
     - *In tension with*: <partner-list/>
@@ -458,12 +468,13 @@ interface quality, quality attributes, and architecture governance.
     - *Additionally*, persist all reported findings 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 and one
-      `{ command: "set", key: "ase-issue-T<n/>", val: "<title/>:
+      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 and one
+      `{ command: "set", key: "ase-issue-<id-prefix/>T<n/>", val: "<title/>:
       <description/>" }` entry per reported TRADEOFF.
 
     Finally, give a final hint by expanding the following (which,
@@ -471,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 P{n}` or `/ase-code-resolve 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-code-resolve <id-prefix/>P{n}` or `/ase-code-resolve <id-prefix/>T{n}` in the same or even a different session.
     </ase-tpl-hint>
 
     </step>

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"