@rse/ase 0.9.13 → 0.9.15

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/dst/ase-mcp.js

@@ -56,8 +56,13 @@ export default class MCPCommand {
     }
     /*  bridge stdio to a Streamable HTTP MCP endpoint on the local service  */
     async runBridge() {
-        /*  ensure the service is running  */
-        let { projectId, port } = await this.ensureService();
+        /*  tentatively load the service identity context; the actual service
+            start/probe happens below through ensureService() and, on failure,
+            is funnelled into the same reconnect machinery used at runtime so
+            that a transient startup failure is recoverable instead of fatal  */
+        const ctx0 = this.loadContext();
+        let projectId = ctx0.projectId;
+        let port = ctx0.port ?? 0;
         /*  create MCP STDIO server (lives for the entire bridge lifetime)  */
         const server = new StdioServerTransport();
         /*  track active client and bridge-level closed state  */
@@ -154,10 +159,17 @@ export default class MCPCommand {
         /*  start server and initial client  */
         await server.start();
         try {
+            /*  ensure the service is running, then connect; both the
+                service start/probe and the connect are covered here so that
+                an initial failure recovers via the reconnect machinery
+                (now in place) instead of crashing the bridge outright  */
+            const ctx = await this.ensureService();
+            projectId = ctx.projectId;
+            port = ctx.port;
             await connectClient();
         }
         catch (err) {
-            /*  service vanished between probe and connect — recover instead of crashing  */
+            /*  initial service start or connect failed — recover instead of crashing  */
             triggerReconnect(`initial connect failed: ${this.asError(err).message}`);
         }
         /*  periodically probe the service; trigger reconnect if it is gone  */

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.15",
     "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.15",
     "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.15",
     "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.15",
     "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.15",
     "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

@@ -89,6 +89,27 @@ problems in *performance* and *efficiency*, or problems in *security*.
         -   many I/O and query round-trips
         -   concurrency bottlenecks
         -   mismatched data structures
+        -   N+1 query patterns (1 parent query, N child queries)
+        -   missing caching/memoization of stable results
+        -   blocking/synchronous calls on hot paths
+        -   unbounded growth (memory leaks, ever-growing collections)
+        -   inefficient string building/concatenation in loops
+        -   premature or repeated serialization/parsing
+        -   lack of batching/pagination for bulk operations
+        -   excessive logging or instrumentation overhead
+        -   chatty network protocols (no connection pooling/keep-alive)
+        -   lock contention and overly coarse-grained locking
+        -   eager/over-fetching of data that is never used
+        -   missing database indexes
+        -   repeated regex (re)compilation in hot paths
+        -   busy-waiting/polling instead of event-driven waits
+        -   transferring uncompressed or overly verbose payloads
+        -   missing short-circuit evaluation in expensive conditions
+        -   recomputing invariants inside loops (loop-invariant code)
+        -   suboptimal batch sizes (too small = overhead, too large = latency)
+        -   inefficient algorithms for sorting/searching already-ordered data
+        -   redundant validation/sanitization of trusted internal data
+        -   missing connection/resource reuse (open-close per operation)
         -   [...]
 
         </if>
@@ -107,6 +128,35 @@ problems in *performance* and *efficiency*, or problems in *security*.
         -   unsafe cryptography
         -   hard-coded secrets
         -   vulnerable dependencies
+        -   injection flaws
+        -   cross-site scripting (XSS) and output-encoding gaps
+        -   cross-site request forgery (CSRF) and missing anti-forgery tokens
+        -   insecure direct object references (IDOR)
+        -   server-side request forgery (SSRF)
+        -   insecure or missing transport encryption (TLS)
+        -   weak session management (fixation, predictable tokens)
+        -   missing rate limiting/anti-automation controls
+        -   overly permissive CORS or file permissions
+        -   verbose error messages leaking internals
+        -   unsafe randomness for security-sensitive values
+        -   mass assignment / over-binding of request parameters
+        -   security misconfiguration (default credentials, debug modes, exposed admin endpoints)
+        -   missing or misconfigured security headers (CSP, HSTS, X-Frame-Options)
+        -   improper certificate/hostname validation (TLS verification disabled)
+        -   insufficient logging and monitoring of security events
+        -   race conditions / TOCTOU (time-of-check to time-of-use) flaws
+        -   integer overflow/underflow and buffer overflows
+        -   use-after-free and memory-safety violations
+        -   privilege escalation through improper privilege dropping
+        -   insecure file upload handling (unrestricted type/size, executable storage)
+        -   unsafe handling of untrusted regular expressions (ReDoS)
+        -   caching of sensitive data in shared or client-side caches
+        -   secrets or sensitive data leaking into logs, traces, or telemetry
+        -   insecure default-deny failures (fail-open instead of fail-closed)
+        -   missing integrity verification (unsigned updates, no subresource integrity)
+        -   excessive data exposure in API responses (returning more fields than needed)
+        -   improper resource cleanup leading to exhaustion (connection/file-descriptor leaks)
+        -   business-logic flaws (bypassable workflows, negative quantities, replay)
         -   [...]
 
         </if>
@@ -130,6 +180,48 @@ problems in *performance* and *efficiency*, or problems in *security*.
         -   null/undefined mishandling
         -   type-coercion bugs
         -   faulty parsing or merge/override semantics
+        -   race conditions and unsynchronized shared state
+        -   resource leaks (unclosed files, handles, connections)
+        -   inverted or swapped function arguments
+        -   incorrect loop termination or accumulator initialization
+        -   shadowed or reassigned variables changing intent
+        -   incomplete switch/case or enum coverage
+        -   silent exception swallowing
+        -   floating-point comparison and rounding errors
+        -   integer overflow/underflow or truncating division
+        -   sign and modulo errors with negative operands
+        -   reference vs. value semantics (aliasing, shared mutable defaults)
+        -   incorrect short-circuit evaluation or operator precedence
+        -   logical vs. bitwise operator confusion
+        -   negation mistakes in compound predicates
+        -   wrong comparison operator (`==` instead of `===`, `<` vs. `<=`, etc)
+        -   inverted condition or swapped if/else branches
+        -   dead or duplicated conditional branches
+        -   fall-through where a break or return was intended
+        -   missing or misplaced base case in recursion (non-termination)
+        -   mutation of a collection while iterating over it
+        -   incorrect index, key, or bounds when accessing collections
+        -   empty-collection or single-element edge cases unhandled
+        -   wrong order of operations in initialization or teardown
+        -   missing cleanup on early return, break, or exception path
+        -   double-free, use-after-free, or double-close of resources
+        -   incorrect time-zone, date arithmetic, or unit conversions
+        -   stale cache or memoization not invalidated on change
+        -   incorrect deep vs. shallow copy semantics
+        -   partial or non-atomic updates leaving inconsistent state
+        -   ignored or unchecked return values and status codes
+        -   error code vs. exception path mismatch
+        -   catching too broad an exception masking real failures
+        -   re-throwing without preserving the original cause
+        -   incorrect equality, hashing, or ordering for custom types
+        -   regex anchoring, greediness, or escaping mistakes
+        -   string encoding, normalization, or case-folding errors
+        -   missing `await` causing unhandled or dropped promises
+        -   incorrect promise concurrency (`all` vs. `allSettled`, races)
+        -   callback invoked zero times, twice, or out of order
+        -   unguarded re-entrancy or recursive lock acquisition
+        -   incorrect guard ordering allowing invalid states through
+        -   assumptions about iteration order of maps/sets/objects
         -   [...]
 
         </if>
@@ -151,8 +243,12 @@ 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", prefix:
+    "ase-issue-" }` 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 +330,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

@@ -93,7 +93,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
         Set <words-before><words/></words-before> (remember the loaded
         word count for the strictly-smaller check in step 3).
 
-        <if condition="<content/> contains 'Created:  <text/>'">
+        <if condition="<content/> contains '⎈   Created:  <text/>'">
         Set <timestamp-created><text/></timestamp-created> (extract the
         original creation timestamp so it can be re-inserted unchanged
         into the condensed <content/> in step 3).
@@ -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-edit/SKILL.md

@@ -320,7 +320,8 @@ Set <content-dirty>true</content-dirty>.
         ISO-style format, which has to be determined by calling the
         `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
         MCP server and use the `text` field of its response. Update
-        <content/> with the new `Modified: <timestamp-modified/>`.
+        the `⚙   Modified: ...` line of <content/> with the new
+        `⚙   Modified: <timestamp-modified/>`.
         Do not output anything.
         </if>
 

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

@@ -213,7 +213,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     2.  Finally, update the plan in <plan/> based on all answers <answer-N/>.
 
-    3.  <if condition="<plan/> contains 'Created:  <text/>'">
+    3.  <if condition="<plan/> contains '⎈   Created:  <text/>'">
         Set <timestamp-created><text/></timestamp-created> (set
         timestamp-created to extracted text)
         </if>
@@ -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

@@ -162,7 +162,8 @@ explicitly requested by this procedure via outputs based on a <template/>!
         ISO-style format, which has to be determined by calling the
         `ase_timestamp(format: "yyyy-LL-dd HH:mm")` tool of the `ase`
         MCP server and use the `text` field of its response. Update
-        <content/> with the new `Modified: <timestamp-modified/>`.
+        the `⚙   Modified: ...` line of <content/> with the new
+        `⚙   Modified: <timestamp-modified/>`.
         Do not output anything.
         </if>
 
@@ -251,12 +252,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

@@ -124,18 +124,35 @@ explicitly requested by this procedure via outputs based on a <template/>!
         (append extracted text to instruction).
         </if>
 
-    6.  <if condition="<content/> contains 'Created:  <text/>'">
+    6.  <if condition="<content/> contains '⎈   Created:  <text/>'">
         Set <timestamp-created><text/></timestamp-created> (set
         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>
-