@rse/ase 0.9.13 → 0.9.14

package/dst/ase-kv.js

@@ -45,10 +45,21 @@ export class KV {
         KV.validateKey(key);
         return KV.store.delete(key);
     }
-    /*  clear all keys; returns the number of keys removed  */
-    static clear() {
-        const n = KV.store.size;
-        KV.store.clear();
+    /*  clear all keys, or just those starting with the given `prefix`;
+        returns the number of keys removed  */
+    static clear(prefix) {
+        if (prefix === undefined || prefix === "") {
+            const n = KV.store.size;
+            KV.store.clear();
+            return n;
+        }
+        let n = 0;
+        for (const key of KV.store.keys()) {
+            if (key.startsWith(prefix)) {
+                KV.store.delete(key);
+                n++;
+            }
+        }
         return n;
     }
     /*  snapshot the entire store into a fresh map (for transactional batch)  */
@@ -112,12 +123,17 @@ export class KVMCP {
         /*  key/value clear  */
         mcp.registerTool("ase_kv_clear", {
             title: "ASE key/value clear",
-            description: "Remove all keys from the in-memory key/value store. " +
+            description: "Remove keys from the in-memory key/value store. " +
+                "If `prefix` is given, only keys starting with `prefix` are removed; " +
+                "otherwise all keys are removed. " +
                 "Returns a status `text` indicating how many keys were removed.",
-            inputSchema: {}
-        }, async () => {
+            inputSchema: {
+                prefix: z.string().optional()
+                    .describe("if given, only remove keys starting with this prefix (otherwise remove all keys)")
+            }
+        }, async (args) => {
             try {
-                const n = KV.clear();
+                const n = KV.clear(args.prefix);
                 return { content: [{ type: "text", text: `kv_clear: OK: removed ${n} key(s)` }] };
             }
             catch (err) {
@@ -151,8 +167,9 @@ export class KVMCP {
         mcp.registerTool("ase_kv_batch", {
             title: "ASE key/value batch",
             description: "Execute an array of in-memory key/value `commands` in a single MCP call. " +
-                "Each entry is an object `{ command: \"clear\"|\"set\"|\"get\"|\"delete\", key?, val? }` " +
+                "Each entry is an object `{ command: \"clear\"|\"set\"|\"get\"|\"delete\", key?, val?, prefix? }` " +
                 "and is dispatched to the corresponding single-op tool. " +
+                "For `clear`, an optional `prefix` restricts removal to keys starting with it. " +
                 "If `transactional` is true, the store is snapshotted up-front and rolled back on the " +
                 "first per-command error (remaining commands are skipped); otherwise per-command errors " +
                 "are recorded and execution continues. " +
@@ -168,7 +185,9 @@ export class KVMCP {
                     key: z.string().optional()
                         .describe("key identifier (required for `set`/`get`/`delete`)"),
                     val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.any()), z.record(z.string(), z.any())]).optional()
-                        .describe("value to store (required for `set`)")
+                        .describe("value to store (required for `set`)"),
+                    prefix: z.string().optional()
+                        .describe("if given for `clear`, only remove keys starting with this prefix (otherwise remove all keys)")
                 }))
                     .describe("ordered list of KV commands to execute"),
                 transactional: z.boolean().optional()
@@ -182,7 +201,7 @@ export class KVMCP {
             for (const c of args.commands) {
                 try {
                     if (c.command === "clear") {
-                        const n = KV.clear();
+                        const n = KV.clear(c.prefix);
                         results.push(`kv_clear: OK: removed ${n} key(s)`);
                         cmdNames.push("clear");
                     }

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.13",
+    "version":                              "0.9.14",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.13",
+    "version":     "0.9.14",
     "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.13",
+    "version":     "0.9.14",
     "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.13",
+    "version":     "0.9.14",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/agents/ase-meta-chat.md

@@ -13,9 +13,9 @@ tools:
 
 @../meta/ase-control.md
 
-1.  Treat `$ARGUMENTS` as a single whitespace-separated string.
-    Set <llm/> to the *first* token.
-    Set <query/> to the *second and all following* tokens.
+1.  Set <args>$ARGUMENTS</args>, the single whitespace-separated string.
+    Set <llm/> to the *first* token of <args/>.
+    Set <query/> to the *second and all following* tokens of <args/>.
     You *MUST* *NOT* output anything related to this step.
 
 2.  Set <server></server> (set to empty).

package/plugin/meta/ase-getopt.md

@@ -96,7 +96,8 @@ set placeholders into the context as a side-effect.
     `<getopt-result/>.opts[<longN/>]`.
     Set <getopt-arguments/> to the value of `<getopt-result/>.args`.
     Set <getopt-info/> to `<getopt-result/>.info`, but remove
-    information about the `help` option.
+    information about the `help` option and any *internal* option
+    whose long name starts with `int-`.
 
 7.  **Display Results**:
     Just output the following <template/>:

package/plugin/meta/ase-skill.md

@@ -250,8 +250,9 @@ Template Patterns
 -   When `<ase-tpl-head title="<title/>"/>` should be expanded, use
     (where <raw-title/> is the visible un-styled text `⧉ ASE: <title/>`,
     <raw-title-len/> is the number of characters in <raw-title/>, and
-    <bar/> is the `─` character repeated exactly (67 - <raw-title-len/>)
-    times -- the very same bar-width rule as `<ase-tpl-foot/>` and
+    <bar/> is the `─` character repeated exactly max(0, 67 - <raw-title-len/>)
+    times -- clamped to zero so an over-long title never yields a negative
+    count -- the very same bar-width rule as `<ase-tpl-foot/>` and
     `<ase-tpl-boxed/>`, so equal visible text yields equal total width):
 
     <template>
@@ -271,8 +272,9 @@ Template Patterns
 -   When `<ase-tpl-foot title="<title/>"/>` should be expanded, use
     (where <raw-title/> is the visible un-styled text `⧉ ASE: <title/>`,
     <raw-title-len/> is the number of characters in <raw-title/>, and
-    <bar/> is the `─` character repeated exactly (67 - <raw-title-len/>)
-    times -- the very same bar-width rule as `<ase-tpl-head/>` and
+    <bar/> is the `─` character repeated exactly max(0, 67 - <raw-title-len/>)
+    times -- clamped to zero so an over-long title never yields a negative
+    count -- the very same bar-width rule as `<ase-tpl-head/>` and
     `<ase-tpl-boxed/>`, so equal visible text yields equal total width):
 
     <template>
@@ -308,8 +310,9 @@ Template Patterns
         </else>
     -   Set <raw-title-len/> to the number of characters in the visible
         un-styled text <raw-title/>.
-    -   Set <bar/> to the `─` character repeated exactly (67 - <raw-title-len/>)
-        times -- the very same bar-width rule as `<ase-tpl-head/>` and
+    -   Set <bar/> to the `─` character repeated exactly max(0, 67 - <raw-title-len/>)
+        times -- clamped to zero so an over-long title never yields a negative
+        count -- the very same bar-width rule as `<ase-tpl-head/>` and
         `<ase-tpl-foot/>`, so equal visible text yields equal total width.
     -   Set <body/> to <content/> with all line-starts prefixed with `│ `.
 
@@ -348,7 +351,8 @@ Template Patterns
     <template>🟠</template>
 
 -   When `<ase-tpl-pad width="<width/>" text="<text/>"/>` should be expanded, use
-    (where <ws/> = ` ` x (<width/> - length("<text/>")), i.e., <ws/> is
-    the ` ` character repeated (<width/> - length("<text/>")) times):
+    (where <ws/> = ` ` x max(0, <width/> - length("<text/>")), i.e., <ws/> is
+    the ` ` character repeated max(0, <width/> - length("<text/>")) times --
+    clamped to zero so an over-long text never yields a negative count):
 
     <template><text/><ws/></template>

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.13",
+    "version":                              "0.9.14",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -399,9 +399,13 @@ interface quality, quality attributes, and architecture governance.
       DEPENDENCY-DIRECTION`).
 
     - The <focal-aspect/> is the aspect that participates in
-      *all* tensions of the cluster. For a size-2 cluster, pick
-      the aspect whose direction is most constrained by the
-      detected style.
+      *all* tensions of the cluster. In a size-2 cluster both
+      aspects participate equally in the single tension, so this
+      rule cannot disambiguate; instead pick the focal aspect by
+      the first applicable tiebreaker: (1) the aspect whose
+      direction is more constrained by the detected style; else
+      (2) the aspect carrying the *higher* finding severity; else
+      (3) the aspect listed *first* in the tension matrix pair.
 
     - *Brevity and precision*: all free-form placeholders
       (<description/>, <focal-state/>, partner-implications)
@@ -438,9 +442,11 @@ 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" }` entry, followed by one
-      `{ command: "set", key: "ase-issue-P<n/>", val: "<title/>:
-      <description/>" }` entry per reported PROBLEM and one
+      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/>:
       <description/>" }` entry per reported TRADEOFF.
     </step>

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

@@ -115,8 +115,16 @@ for the technology stack to *provide* the *needed functionality*
         <keyword-L/> (L=1-M), which allow you to search for suitable
         components.
 
-    3.  In the to be discovered result set of components <component-K/>
-        (K=1-N), remember the component name as <name-K/>, the
+    3.  Determine the *candidate pool size* <pool/> as twice the
+        <getopt-option-limit/> (i.e. <pool/> = 2 &times;
+        <getopt-option-limit/>). Each discovery source below may fetch up
+        to <pool/> candidates so that the later ranking and trimming
+        (which alone is governed by <getopt-option-limit/>) has a
+        meaningful set to choose from.
+
+        In the to be discovered candidate set of components <component-K/>
+        (K=1-C, where C is the merged and deduplicated candidate count),
+        remember the component name as <name-K/>, the
         official package name as <package-K/>, the latest version as
         <version-K/>, the stars as <stars-K/>, the created date as
         <created-K/>, the last updated date as <updated-K/>, the total
@@ -126,13 +134,13 @@ for the technology stack to *provide* the *needed functionality*
 
         1.  Based on the essential keywords <keyword-L/> (L=1-M),
             use the `ase-meta-search` skill in a subagent to *generally*
-            discover an initial set of a maximum of <getopt-option-limit/> *NPM packages*
+            discover an initial set of a maximum of <pool/> *NPM packages*
             <component-K/> and at least their real name <name-K/> and
             their unique package names <package-K/>.
 
-        2.  Use the shell command `npm search --json --searchlimit <getopt-option-limit/>
+        2.  Use the shell command `npm search --json --searchlimit <pool/>
             "<keyword-1/>" [...] "<keyword-M/>"` to *specifically*
-            discover an additional set of a maximum of <getopt-option-limit/> *NPM packages*
+            discover an additional set of a maximum of <pool/> *NPM packages*
             <component-K/> and at least their unique package names
             <package-K/>, based on the essential keywords <keyword-L/>
             (L=1-M). Merge the results into the already existing result
@@ -142,14 +150,14 @@ for the technology stack to *provide* the *needed functionality*
 
         1.  Based on the essential keywords <keyword-L/> (L=1-M),
             use the `ase-meta-search` skill in a subagent to *generally*
-            discover an initial set of a maximum of <getopt-option-limit/> *Maven packages*
+            discover an initial set of a maximum of <pool/> *Maven packages*
             <component-K/> and at least their real name <name-K/> and
             their unique Maven coordinates <package-K/> of the form
             `groupId:artifactId`.
 
-        2.  Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=<keyword-1/>+[...]+<keyword-M/>&rows=<getopt-option-limit/>&wt=json'`
+        2.  Use the shell command `curl -s 'https://search.maven.org/solrsearch/select?q=<keyword-1/>+[...]+<keyword-M/>&rows=<pool/>&wt=json'`
             to *specifically* discover an additional set of a maximum
-            of <getopt-option-limit/> *Maven packages* <component-K/> and at least their
+            of <pool/> *Maven packages* <component-K/> and at least their
             unique Maven coordinates <package-K/> (i.e. `<g/>:<a/>` from
             each result document's `g` and `a` fields), based on the
             essential keywords <keyword-L/> (L=1-M). Merge the results
@@ -157,22 +165,25 @@ for the technology stack to *provide* the *needed functionality*
             entries by Maven coordinate.
 
     6.  Call the `ase_component_info(stack: "<stack/>", components:
-        [ "<package-1/>", ..., "<package-N/>" ])` tool of the `ase` MCP
-        server *once* for the entire set of discovered packages.
+        [ "<package-1/>", ..., "<package-C/>" ])` tool of the `ase` MCP
+        server *once* for the entire candidate set of discovered packages.
         The tool dispatches internally on <stack/> and fetches all
         metadata in maximum parallel and returns an array of objects `{
         name, version, created, updated, repository, stars, downloads,
         rank }`. For each
-        component <component-K/> (K=1-N) read from its corresponding
+        component <component-K/> (K=1-C) read from its corresponding
         entry: <version-K/> from `version`, <updated-K/> from `updated`,
         <created-K/> from `created`, <repository-K/> from `repository`,
         <stars-K/> from `stars` (numeric or `N.A.`), <downloads-K/>
         from `downloads` (numeric or `N.A.`) and <rank-K/> from `rank`
         (numeric).
 
-    7.  Sort, in descending order, the discovered components
-        <component-K/> (K=1-N) by their `rank` field and trim the result
-        list to just a maximum of <getopt-option-limit/> total components.
+    7.  Sort, in descending order, the discovered candidate components
+        <component-K/> (K=1-C) by their `rank` field and trim the result
+        list to just a maximum of <getopt-option-limit/> total components,
+        which establishes the final retained set <component-K/> (K=1-N,
+        where N is at most <getopt-option-limit/>). All subsequent steps
+        operate solely on this retained set.
 
     8.  For each component <component-K/> (K=1-N), research and then
         decide which *one* of *USP* (Unique Selling Point -- what makes

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

@@ -151,8 +151,11 @@ problems in *performance* and *efficiency*, or problems in *security*.
 
     Then renumber the surviving problems contiguously as `P<n/>` with
     <n/> = 1, 2, ... in the original ordering. If *all* problems are
-    dropped, skip the per-problem report but still emit the final hint
-    <template/> below.
+    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" }` entry,
+    and still emit the final hint <template/> below.
 
     In this STEP 3, for *EVERY* surviving problem, immediately report
     it with the following output <template/>, based on concise bullet
@@ -234,9 +237,11 @@ problems in *performance* and *efficiency*, or problems in *security*.
     -   *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" }` entry, 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-" }`
+        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.
 
     Finally, output the following <template/> to give a final hint:
 

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

@@ -107,6 +107,16 @@ related to a set of code quality aspects.
         "ase-code-lint", scope: "session:<ase-session-id/>")` tool
         from the `ase` MCP server. Do not output anything in this substep.
 
+        *Critical safety invariant*: the marker set here grants `Edit`
+        auto-approval and *MUST* be cleared again (substep 3 below)
+        *before* this skill yields control, *regardless* of how the
+        iteration in substep 2 ends - whether it completes normally,
+        is aborted early (e.g. an `Edit` failure, an unparseable value,
+        or any other unexpected condition), or is otherwise interrupted.
+        If you ever stop or bail out of substep 2 early, you *MUST*
+        still perform substep 3 first. Never leave this marker active
+        for a later, unrelated `Edit`.
+
     2.  Iterate over all problems:
 
         <for items="<problems/>">
@@ -143,16 +153,46 @@ related to a set of code quality aspects.
                     Set <new-text/>       to the `new_text`       field of <item/>.
                     Set <context-after/>  to the `context_after`  field of <item/>.
 
-                2.  Set <old-start/> to the line of the first hunk line, i.e.,
-                    the line of <context-before/> (one before <line/>).
-                    Set <new-start/> to the same as <old-start/> (the unchanged
-                    <context-before/> line shares the same start in both files).
-                    Set <old-count/> to the total number of old-side hunk lines, i.e.,
-                    the number of lines in <context-before/>, <old-text/>, and
-                    <context-after/> combined.
-                    Set <new-count/> to the total number of new-side hunk lines, i.e.,
-                    the number of lines in <context-before/>, <new-text/>, and
-                    <context-after/> combined.
+                2.  Determine the hunk *body* as an ordered list of lines,
+                    each carrying a one-character prefix (` ` for context,
+                    `-` for old-side, `+` for new-side). Build it by
+                    concatenating, in order and *skipping any part that is
+                    empty*:
+
+                    - one ` `-prefixed line for *each* line of
+                      <context-before/> (if non-empty),
+                    - one `-`-prefixed line for *each* line of <old-text/>
+                      (if non-empty; split <old-text/> on newlines),
+                    - one `+`-prefixed line for *each* line of <new-text/>
+                      (if non-empty; split <new-text/> on newlines),
+                    - one ` `-prefixed line for *each* line of
+                      <context-after/> (if non-empty).
+
+                    Set <hunk-body/> to those prefixed lines joined by
+                    newlines.
+
+                    Set <old-count/> to the number of old-side hunk lines,
+                    i.e., the combined line count of <context-before/>,
+                    <old-text/>, and <context-after/> (each empty part
+                    counts as `0`).
+                    Set <new-count/> to the number of new-side hunk lines,
+                    i.e., the combined line count of <context-before/>,
+                    <new-text/>, and <context-after/> (each empty part
+                    counts as `0`).
+
+                    Set <old-start/> to the 1-based line number of the
+                    *first* old-side hunk line: if <context-before/> is
+                    non-empty, that is its line (one before <line/>);
+                    otherwise it is <line/> itself (the first line of
+                    <old-text/>). For a hunk that *only inserts* new lines
+                    (empty <old-text/> *and* empty context), set it to the
+                    line *before* which the insertion happens, clamped to a
+                    minimum of `0`, so a top-of-file insertion yields
+                    `@@ -0,0 ... @@`.
+                    Set <new-start/> to the same value as <old-start/>, but
+                    clamped to a minimum of `1` whenever <new-count/> is
+                    greater than `0` (the corrected side then has a real
+                    first line).
 
                 3.  If <context/> is not empty, set
                     <context><context/>,</context> (append a comma).
@@ -160,14 +200,13 @@ related to a set of code quality aspects.
 
                     <template>`<file/>`:<line/></template>
 
-                4.  Append the following <template/> to <diff-file/>:
+                4.  Append the following <template/> to <diff-file/>,
+                    emitting <hunk-body/> verbatim (one already-prefixed
+                    line per line, with no extra blank or space-only lines):
 
                     <template>
                     @@ -<old-start/>,<old-count/> +<new-start/>,<new-count/> @@
-                     <context-before/>
-                    -<old-text/>
-                    +<new-text/>
-                     <context-after/>
+                    <hunk-body/>
                     </template>
 
                 </for>

package/plugin/skills/ase-docs-proofread/SKILL.md

@@ -96,6 +96,16 @@ Analyze documents for spelling, punctuation, or grammar errors
         "ase-docs-proofread", scope: "session:<ase-session-id/>")` tool
         from the `ase` MCP server. Do not output anything in this substep.
 
+        *Critical safety invariant*: the marker set here grants `Edit`
+        auto-approval and *MUST* be cleared again (substep 3 below)
+        *before* this skill yields control, *regardless* of how the
+        iteration in substep 2 ends - whether it completes normally,
+        is aborted early (e.g. an `Edit` failure, an unparseable value,
+        or any other unexpected condition), or is otherwise interrupted.
+        If you ever stop or bail out of substep 2 early, you *MUST*
+        still perform substep 3 first. Never leave this marker active
+        for a later, unrelated `Edit`.
+
     2.  Iterate over all problems:
 
         <for items="<problems/>">
@@ -119,19 +129,44 @@ Analyze documents for spelling, punctuation, or grammar errors
 
         3.  <if condition="<getopt-option-auto/> is not 'true'">
 
-            Set <old-start/> to the line of the first hunk line, i.e.,
-            the line of <context-before/> (one before <line/>).
-            Set <new-start/> to the same as <old-start/> (the unchanged
-            <context-before/> line shares the same start in both files).
-            Set <old-count/> to the total number of old-side hunk lines, i.e.,
-            the number of lines in <context-before/>, <old-text/>, and
-            <context-after/> combined.
-            Set <new-count/> to the total number of new-side hunk lines, i.e.,
-            the number of lines in <context-before/>, <new-text/>, and
-            <context-after/> combined.
+            Determine the hunk *body* as an ordered list of lines, each
+            carrying a one-character prefix (` ` for context, `-` for
+            old-side, `+` for new-side). Build it by concatenating, in
+            order and *skipping any part that is empty*:
+
+            - one ` `-prefixed line for *each* line of <context-before/>
+              (if non-empty),
+            - one `-`-prefixed line for *each* line of <old-text/>
+              (if non-empty; split <old-text/> on newlines),
+            - one `+`-prefixed line for *each* line of <new-text/>
+              (if non-empty; split <new-text/> on newlines),
+            - one ` `-prefixed line for *each* line of <context-after/>
+              (if non-empty).
+
+            Set <hunk-body/> to those prefixed lines joined by newlines.
+
+            Set <old-count/> to the number of old-side hunk lines, i.e.,
+            the combined line count of <context-before/>, <old-text/>, and
+            <context-after/> (each empty part counts as `0`).
+            Set <new-count/> to the number of new-side hunk lines, i.e.,
+            the combined line count of <context-before/>, <new-text/>, and
+            <context-after/> (each empty part counts as `0`).
+
+            Set <old-start/> to the 1-based line number of the *first*
+            old-side hunk line: if <context-before/> is non-empty, that is
+            its line (one before <line/>); otherwise it is <line/> itself
+            (the first line of <old-text/>). For a hunk that *only inserts*
+            new lines (empty <old-text/> *and* empty context), set it to the
+            line *before* which the insertion happens, clamped to a minimum
+            of `0`, so a top-of-file insertion yields `@@ -0,0 ... @@`.
+            Set <new-start/> to the same value as <old-start/>, but clamped
+            to a minimum of `1` whenever <new-count/> is greater than `0`
+            (the corrected side then has a real first line).
 
             Render the proposed correction as a *unified diff* with *up to
-            two* lines of context in a fenced block based on the following <template/>:
+            two* lines of context in a fenced block based on the following
+            <template/>, emitting <hunk-body/> verbatim (one already-prefixed
+            line per line, with no extra blank or space-only lines):
 
             <template>
 
@@ -141,10 +176,7 @@ Analyze documents for spelling, punctuation, or grammar errors
             --- <file/> (original)
             +++ <file/> (corrected)
             @@ -<old-start/>,<old-count/> +<new-start/>,<new-count/> @@
-             <context-before/>
-            -<old-text/>
-            +<new-text/>
-             <context-after/>
+            <hunk-body/>
             ```
 
             </template>

package/plugin/skills/ase-meta-brainstorm/SKILL.md

@@ -137,8 +137,11 @@ Honor the following tenets throughout the brainstorming:
         4.  Dispatch on the dialog <result/>:
 
             -   If <result/> is `CANCEL`:
-                Skip the remaining sub-steps of this iteration cycle and
-                continue directly with sub-step 2 below (cancellation handling).
+                Skip the remaining sub-steps of this iteration cycle, break
+                out of the iteration cycle entirely, and continue directly
+                with the outer item `2.` (cancellation handling) that
+                immediately follows this iteration cycle `1.` within this
+                STEP 2.
 
             -   If <result/> starts with `ERROR:`:
                 Ask the user interactively, without a special tool, the

package/plugin/skills/ase-meta-evaluate/SKILL.md

@@ -201,12 +201,18 @@ multi-*criteria* decision matrix.
     -   Determine rating distance percentage <percentage/> between
         <alternative-K/> and <alternative-X/> from their *raw,
         unrounded* ratings as follows. If <rating-K/> is exactly zero,
-        skip the division entirely and treat <percentage/> as if it
-        were equal to <distance/> (so a true zero tie with <distance/>
-        = 0 falls into the *MULTIPLE BEST* branch below, while a non-zero
-        gap with zero best is routed by the magnitude of <distance/>
-        through the same thresholds as <percentage/> otherwise). Do not
-        output anything.
+        skip the division entirely (it is undefined against a zero
+        anchor) and classify directly by <distance/> instead of routing a
+        raw rating magnitude through the ratio thresholds below: if
+        <distance/> is also exactly zero, both best and second best rate
+        zero, which is a genuine tie, so set <percentage/> = 0 to fall
+        into the *MULTIPLE BEST* branch below; otherwise <distance/> > 0
+        means the second best rates strictly negative (since <rating-K/>
+        is the maximum), so there is a clear positive gap to a worse
+        runner-up and <alternative-K/> is an unambiguous winner, hence set
+        <percentage/> = 1 (a sentinel exceeding all small-distance
+        thresholds) to fall through to the plain *BEST ALTERNATIVE* branch.
+        Do not output anything.
 
     -   Otherwise (<rating-K/> is non-zero), calculate: <percentage/> =
         <distance/> / abs(<rating-K/>). Do not output anything.

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

@@ -280,12 +280,3 @@ explicitly requested by this procedure via outputs based on a <template/>!
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- hand-off to pre-flight**
             </template>
-
-        -   If <result/> matches `OTHER: <text/>` or is any other
-            unrecognized value:
-            Treat it as `DONE` (the condensed plan is already saved):
-            only output the following <template/> and then *STOP*.
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan condensed -- done**
-            </template>

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

@@ -326,12 +326,3 @@ explicitly requested by this procedure via outputs based on a <template/>!
             <template>
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to implementation**
             </template>
-
-        -   If <result/> matches `OTHER: <text/>` or is any other
-            unrecognized value:
-            Treat it as `DONE` (the updated plan is already saved):
-            only output the following <template/> and then *STOP*.
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- done**
-            </template>

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

@@ -28,7 +28,8 @@ Configure Task Id
 
 1.  Determine request:
     <request><getopt-arguments/></request>
-    Inherit the always existing <ase-session-id/> from the current context.
+    Inherit the always existing <ase-session-id/> and the current
+    <ase-task-id/> from the current context.
 
 2.  <if condition="<request/> is NOT empty AND <request/> does NOT match the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`">
     Only output the following <template/> and then immediately
@@ -44,6 +45,8 @@ Configure Task Id
         tool from the `ase` MCP server and set <text/> to its
         `text` output. Check the response as mandated above; only
         on a clean response set <ase-task-id><text/></ase-task-id>.
+        On an `ERROR:`/`WARNING:` response, keep the <ase-task-id/>
+        inherited from the current context as the fallback.
 
     -   Output:
         <template>

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

@@ -223,12 +223,3 @@ explicitly requested by this procedure via outputs based on a <template/>!
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented -- hand-off to delete task**
             </template>
 
-        -   If <result/> matches `OTHER: <text/>` or is any other
-            unrecognized value:
-            Treat it as `DONE` (the plan is already implemented):
-            only output the following <template/> and then *STOP*.
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan implemented -- done**
-            </template>
-

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

@@ -251,12 +251,3 @@ explicitly requested by this procedure via outputs based on a <template/>!
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to implement**
             </template>
 
-        -   If <result/> matches `OTHER: <text/>` or is any other
-            unrecognized value:
-            Treat it as `DONE` (the plan is already preflighted):
-            only output the following <template/> and then *STOP*.
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- done**
-            </template>
-

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

@@ -129,13 +129,30 @@ explicitly requested by this procedure via outputs based on a <template/>!
         timestamp-created to extracted text)
         </if>
 
-    7.  Create a new plan from scratch and store the result as
+    7.  <if condition="<instruction/> is empty or contains only whitespace">
+        The WHAT/WHY extraction yielded no usable text (e.g. a
+        `-   **WHAT**:` line existed but captured empty text, so the
+        whole-content fallback above did not fire). Fall back to the
+        full previous plan content: set <instruction><content/></instruction>
+        (set instruction to content).
+        <if condition="<instruction/> is still empty or contains only whitespace">
+            There is nothing to reboot from. Only output the following
+            <template/> and then immediately *STOP* processing the entire
+            current skill:
+
+            <template>
+            ⧉ **ASE**: ☻ skill: **ase-task-reboot**, ▶ ERROR: empty instruction -- nothing to reboot from
+            </template>
+        </if>
+        </if>
+
+    8.  Create a new plan from scratch and store the result as
         <content/> by closely following the defined plan format
         <format/> and injecting into it all the information from
         the <instruction/> and all decisions you derived from the
         <instruction/>.
 
-    8.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
+    9.  Call the `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the
         `ase` MCP server and use the `text` field of its response for
         <timestamp-modified/> information. If <timestamp-created/> is
         still unset (because the previous <content/> had no `Created:`
@@ -145,12 +162,12 @@ explicitly requested by this procedure via outputs based on a <template/>!
         <timestamp-modified/> information and calculate the number of
         words <words/> of <content/>.
 
-    9.  Call the `ase_task_save(id: "<ase-task-id/>",
+    10. Call the `ase_task_save(id: "<ase-task-id/>",
         text: "<content/>")` of the `ase` MCP server to save the updated
         task plan content. Do not output anything related to this MCP
         call.
 
-    10. Only output the following <template/> and continue processing:
+    11. Only output the following <template/> and continue processing:
 
         <template>
         ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan rebooted**
@@ -244,12 +261,3 @@ explicitly requested by this procedure via outputs based on a <template/>!
             ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- hand-off to pre-flight**
             </template>
 
-        -   If <result/> matches `OTHER: <text/>` or is any other
-            unrecognized value:
-            Treat it as `DONE` (the updated plan is already saved):
-            only output the following <template/> and then *STOP*.
-
-            <template>
-            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan updated -- done**
-            </template>
-