@rse/ase 0.9.12 → 0.9.14

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-craft/SKILL.md

@@ -319,7 +319,19 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         as <head/> (or `none` if the list is `none`/empty).
         Set <args>--int-reuse-task</args>.
 
-        1.  <if condition="<head/> is equal `IMPLEMENT`">
+        1.  <if condition="<head/> is equal `DONE`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `DONE`
+            means the freshly composed plan is finalized as-is, so do
+            *not* hand off to `ase-task-edit`. Only output the following
+            <template/> and then *STOP*. Do *not* implement the plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
+            </template>
+            </if>
+
+        2.  <elseif condition="<head/> is equal `IMPLEMENT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -327,9 +339,9 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             </if>
             Call the tool `Skill(skill: "ase:ase-task-implement", args: "<args/>")`
             to *implement* the freshly composed plan, bypassing `ase-task-edit`.
-            </if>
+            </elseif>
 
-        2.  <elseif condition="<head/> is equal `PREFLIGHT`">
+        3.  <elseif condition="<head/> is equal `PREFLIGHT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -339,7 +351,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        3.  <else>
+        4.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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

@@ -8,7 +8,6 @@ user-invocable: true
 disable-model-invocation: false
 effort: high
 allowed-tools:
-    - "Skill"
     - "Agent"
 ---
 

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

@@ -12,7 +12,7 @@ allowed-tools:
     - "Bash(sort *)"
     - "Bash(uniq *)"
     - "Bash(head *)"
-    - "Skill"
+    - "Bash(git log * | grep * | sort * | uniq * | sort * | head *)"
     - "Agent"
 ---
 

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,34 +153,62 @@ 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.  If <context/> is not empty, set
+                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).
                     Then append the following <template/> to <context/>:
 
                     <template>`<file/>`:<line/></template>
 
-                3.  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>
 
-                    Hints:
-                    -   The <old-start/> is the line of the first hunk line, i.e.,
-                        the line of <context-before/> (one before <line/>).
-                    -   The <new-start/> is the same as <old-start/> (the unchanged
-                        <context-before/> line shares the same start in both files).
-                    -   The <old-count/> is the total number of old-side hunk lines, i.e.,
-                        the number of lines in <context-before/>, <old-text/>, and
-                        <context-after/> combined.
-                    -   The <new-count/> is the total number of new-side hunk lines, i.e.,
-                        the number of lines in <context-before/>, <new-text/>, and
-                        <context-after/> combined.
-
                 </for>
 
             3.  Append <diff-file/> to <diff/>.

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

@@ -308,7 +308,19 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         as <head/> (or `none` if the list is `none`/empty).
         Set <args>--int-reuse-task</args>.
 
-        1.  <if condition="<head/> is equal `IMPLEMENT`">
+        1.  <if condition="<head/> is equal `DONE`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `DONE`
+            means the freshly composed plan is finalized as-is, so do
+            *not* hand off to `ase-task-edit`. Only output the following
+            <template/> and then *STOP*. Do *not* implement the plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
+            </template>
+            </if>
+
+        2.  <elseif condition="<head/> is equal `IMPLEMENT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -316,9 +328,9 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             </if>
             Call the tool `Skill(skill: "ase:ase-task-implement", args: "<args/>")`
             to *implement* the freshly composed plan, bypassing `ase-task-edit`.
-            </if>
+            </elseif>
 
-        2.  <elseif condition="<head/> is equal `PREFLIGHT`">
+        3.  <elseif condition="<head/> is equal `PREFLIGHT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -328,7 +340,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        3.  <else>
+        4.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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

@@ -71,6 +71,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         <problem-id/> and stop processing.
 
     2.  <if condition="
+            <problem-id/> is not set AND
             <problem/> matches the regexp `^[a-zA-Z][a-zA-Z0-9_-]*$`
         ">
         Set <ase-task-id><problem/></ase-task-id> (set task id to problem)
@@ -366,7 +367,19 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         as <head/> (or `none` if the list is `none`/empty).
         Set <args>--int-reuse-task</args>.
 
-        1.  <if condition="<head/> is equal `IMPLEMENT`">
+        1.  <if condition="<head/> is equal `DONE`">
+            Consume the head: set <getopt-option-next/> to the remaining
+            tokens (joined back with `,`, or `none` if empty). `DONE`
+            means the freshly composed plan is finalized as-is, so do
+            *not* hand off to `ase-task-edit`. Only output the following
+            <template/> and then *STOP*. Do *not* implement the plan.
+
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **plan finalized -- done**
+            </template>
+            </if>
+
+        2.  <elseif condition="<head/> is equal `IMPLEMENT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -374,9 +387,9 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             </if>
             Call the tool `Skill(skill: "ase:ase-task-implement", args: "<args/>")`
             to *implement* the freshly composed plan, bypassing `ase-task-edit`.
-            </if>
+            </elseif>
 
-        2.  <elseif condition="<head/> is equal `PREFLIGHT`">
+        3.  <elseif condition="<head/> is equal `PREFLIGHT`">
             Consume the head: set <getopt-option-next/> to the remaining
             tokens (joined back with `,`, or `none` if empty).
             <if condition="<getopt-option-next/> is not equal `none`">
@@ -386,7 +399,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
             to *preflight* the freshly composed plan, bypassing `ase-task-edit`.
             </elseif>
 
-        3.  <else>
+        4.  <else>
             Hand off to `ase-task-edit`.
             <if condition="<head/> is equal `EDIT`">
                 Consume the head: set <getopt-option-next/> to the remaining

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,8 +129,44 @@ Analyze documents for spelling, punctuation, or grammar errors
 
         3.  <if condition="<getopt-option-auto/> is not 'true'">
 
+            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>
 
@@ -130,26 +176,11 @@ 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>
 
-            Hints:
-            -   The <old-start/> is the line of the first hunk line, i.e.,
-                the line of <context-before/> (one before <line/>).
-            -   The <new-start/> is the same as <old-start/> (the unchanged
-                <context-before/> line shares the same start in both files).
-            -   The <old-count/> is the total number of old-side hunk lines, i.e.,
-                the number of lines in <context-before/>, <old-text/>, and
-                <context-after/> combined.
-            -   The <new-count/> is the total number of new-side hunk lines, i.e.,
-                the number of lines in <context-before/>, <new-text/>, and
-                <context-after/> combined.
-
             </if>
 
         4.  <if condition="<getopt-option-auto/> is not 'true'">

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-compat/SKILL.md

@@ -71,7 +71,7 @@ Procedure
         `width="<w/>"` and read the attribute `width` back.
         Record actual result for `xml-placeholders/nested-attr`.
 
-    6.  *entity*: Evaluate the XML entity `&#x25CB;` and get the rendered
+    6.  *entity*: Evaluate the XML entity `&#x29BF;` and get the rendered
         Unicode character.
         Record actual result for `xml-placeholders/entity`.
 
@@ -152,8 +152,6 @@ Procedure
 
     Set <re-total/> to the number of regex probes above.
 
-    </step>
-
 5.  STEP 5: Probe Arithmetic
 
     Execute *all* of the following arithmetic probes (in the given
@@ -181,8 +179,6 @@ Procedure
 
     Set <arith-total/> to the number of arithmetic probes above.
 
-    </step>
-
 6.  STEP 6: Fetch Expected Values and Score
 
     Call the `ase_compat()` tool of the `ase` MCP server with an
@@ -209,8 +205,6 @@ Procedure
     -   Set <re-pass/>    to the number of `regex/*`            probes that passed.
     -   Set <arith-pass/> to the number of `arithmetic/*`       probes that passed.
 
-    </step>
-
 7.  STEP 7: Compute and Report Compatibility
 
     Compute each category's *pass-rate* (a value in 0.0…1.0) by dividing
@@ -269,9 +263,7 @@ Procedure
     4.  If <failures/> is not empty:
         Append to <verdict/> the suffix ` (failed: <failures/>)`.
 
-    Output the final compatibility report with the following <template/>:
-
-    <template>
+    Finally, output the compatibility report:
 
     **RESULTS**:
 
@@ -284,5 +276,3 @@ Procedure
     | **OVERALL**          |             |                              | **<overall-pct/>%** |
 
     **VERDICT**: <verdict/>
-
-    </template>

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

@@ -274,9 +274,9 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         <ase-tpl-bullet-signal/> **CHANGE RISK REPORT**: Overall: **<band/>** (<aggregate/>/5)
 
-        | Axis        | Score      | Findings                                                    |
-        | ----------- | ---------- | ----------------------------------------------------------- |
-        | **<axis/>** | <score/>/5 | ● **EVIDENCE**: <evidence/> ● **MITIGATION**: <mitigation/> |
+        | Axis        | Score      | Findings                                                                                              |
+        | ----------- | ---------- | ----------------------------------------------------------------------------------------------------- |
+        | **<axis/>** | <score/>/5 | ● **EVIDENCE**: <evidence/><if condition="axis score is `>= 4`"> ● **MITIGATION**: <mitigation/></if> |
         </template>
     </step>
 

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

@@ -81,15 +81,17 @@ multi-*criteria* decision matrix.
     -   For each alternative <alternative-K/> (K=1-N), decide whether
         it is a genuine member of <class-of-alternatives/>. If any
         <alternative-K/> is *not* a member (i.e. the alternatives are not
-        mutually comparable within a single class), let <alternative-J/>
-        (J=1-P, P<=N) be the subset of non-member alternatives, output the
-        following <template/> and *stop the entire flow* immediately without
-        executing any further steps:
+        mutually comparable within a single class), collect the subset
+        of non-member alternatives into the space-separated list
+        <non-members/> (the <alternative-K/> for which the membership
+        decision was negative), output the following <template/> and
+        *stop the entire flow* immediately without executing any further
+        steps:
 
         <template>
         <ase-tpl-bullet-signal/> **ERROR: INCOMPARABLE ALTERNATIVES**: *<class-of-alternatives/>*
 
-        <for items="<alternative-J/> [...]">
+        <for items="<non-members/>">
         ⚑ **<item/>** (*member of a different class*)
         </for>
         </template>
@@ -199,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.
@@ -217,29 +225,29 @@ multi-*criteria* decision matrix.
         appear large; the all-negative regime is surfaced as a dedicated
         warning branch below. Do not output anything.
 
-    -   If <percentage/> is less than 0.01 (i.e. <distance/> is
-        effectively zero relative to abs(<rating-K/>)), stop the flow after
-        you output just the following <template/> and do not output anything
-        else:
-
-        <template>
-        <ase-tpl-bullet-signal/> **ERROR**: ✘ *MULTIPLE BEST ALTERNATIVES FOUND*,
-        ⚠ *Please give some hints on the criteria to ensure a single best alternative!*
-        </template>
-
-    -   Otherwise, if <rating-K/> is less than zero (i.e. all alternatives
+    -   If <rating-K/> is less than zero (i.e. all alternatives
         rate negatively and the "best" is merely the least-bad), stop the
         flow after you output just the following <template/> and do not
         output anything else. This all-negative check is evaluated *before*
-        the small-distance check below, so that an all-negative alternative
+        the small-distance checks below, so that an all-negative alternative
         set with a small winning gap surfaces the all-negative warning rather
-        than being masked by the small-distance branch:
+        than being masked by the multiple-best or small-distance branches:
 
         <template>
         <ase-tpl-bullet-signal/> **BEST ALTERNATIVE**: ⚑ **<alternative-K/>**
         ⚠ *ATTENTION: all alternatives rate negatively; this is the least-bad choice, not a strong winner!*
         </template>
 
+    -   Otherwise, if <percentage/> is less than 0.01 (i.e. <distance/> is
+        effectively zero relative to abs(<rating-K/>)), stop the flow after
+        you output just the following <template/> and do not output anything
+        else:
+
+        <template>
+        <ase-tpl-bullet-signal/> **ERROR**: ✘ *MULTIPLE BEST ALTERNATIVES FOUND*,
+        ⚠ *Please give some hints on the criteria to ensure a single best alternative!*
+        </template>
+
     -   Otherwise, if <percentage/> is less than 0.10, stop the flow after
         you output just the following <template/> and do not output anything
         else: