@rse/ase 0.9.11 → 0.9.13

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

@@ -0,0 +1,278 @@
+---
+name: ase-meta-compat
+description: >
+    Self-test the LLM's ability to execute ASE's core interpreter
+    machinery (control flow, XML placeholders, regex matching,
+    arithmetic) and report an overall compatibility rating. Use when
+    the user wants to check how well the current model/harness is
+    compatible with ASE, or asks to "test ASE compatibility" or "check
+    ASE compatibility".
+user-invocable: true
+disable-model-invocation: true
+---
+
+@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
+
+Self-Test ASE Compatibility
+===========================
+
+Objective
+---------
+
+*Self-test* how faithfully the current LLM (and its harness) executes the
+four *core interpreter primitives* that every ASE skill silently relies
+on -- *control flow*, *XML placeholders*, *regex matching*, and
+*arithmetic* -- and report an overall **0%…100% compatibility** rating.
+
+This skill is unusual: it is both the *test definition* and the *system
+under test*. Each *probe* is a pure ASE construct that you execute and
+record its *actual* result. You *MUST NOT* compare against any expected
+value until STEP 6. Do not fabricate passes: a probe whose actual result
+differs from its expected result *MUST* be recorded as a *fail*.
+
+Notice that this skill intentionally does not strictly follow the ASE
+skill format, especially it does not include any meta skill information,
+etc.
+
+Procedure
+---------
+
+1.  STEP 1: Initialize Self-Test
+
+    Initialize the running map of actual probe results <actuals></actuals>
+    (set to empty) -- every probe in STEPs 2-5 stores its result here as
+    a `<category/>/<probe-name/>` entry with its *actual* computed value.
+
+    Initialize the running list of failed probes <failures></failures>
+    (set to empty) -- this is populated only in STEP 6 after comparing
+    actuals against the expected values.
+
+2.  STEP 2: Probe XML Placeholders
+
+    Execute *all* of the following XML-placeholder probes (in the given
+    order). For each probe, record the *actual* result in <actuals/>
+    under the key `xml-placeholders/<probe-name/>`. Do *not* compare to
+    any expected value here.
+
+    1.  *get-and-set*: Set <v>42</v>, then get <v/>.
+        Record actual result for `xml-placeholders/get-and-set`.
+
+    2.  *self-ref*: Set <v>42</v>, then set `<v>pre_<v/></v>`, then get <v/>.
+        Record actual result for `xml-placeholders/self-ref`.
+
+    3.  *overwrite*: Set <v>42</v>, then set `<v>99</v>`, then get <v/>.
+        Record actual result for `xml-placeholders/overwrite`.
+
+    4.  *indexed*: Set `<eval-1-2>+1</eval-1-2>` and `<eval-2-1>-1</eval-2-1>`,
+        then get <eval-1-2/> and <eval-2-1/> via `<eval-1-2/>,<eval-2-1/>`.
+        Record actual result for `xml-placeholders/indexed`.
+
+    5.  *nested-attr*: With <w>20</w>, build the value of an XML attribute
+        `width="<w/>"` and read the attribute `width` back.
+        Record actual result for `xml-placeholders/nested-attr`.
+
+    6.  *entity*: Evaluate the XML entity `&#x29BF;` and get the rendered
+        Unicode character.
+        Record actual result for `xml-placeholders/entity`.
+
+    Set <xml-total/> to the number of XML-placeholder probes above.
+
+3.  STEP 3: Probe Control Flow
+
+    Execute *all* of the following control-flow probes (in the given
+    order). For each probe, record the *actual* result in <actuals/>
+    under the key `control-flow/<probe-name/>`. Do *not* compare to any
+    expected value here.
+
+    1.  *branch*: Set <a>3</a>, then evaluate
+        `<if condition="<a/> is greater than 5">big</if>
+        <elseif condition="<a/> is greater than 2">mid</elseif>
+        <else>small</else>`.
+        Record actual result for `control-flow/branch`.
+
+    2.  *while-sum*: Set <s>0</s> and <i>1</i>, then evaluate
+        `<while condition="<i/> is less than or equal to 5">
+        set <s/> to <s/> + <i/>,
+        set <i/> to <i/> + 1
+        </while>`.
+        Record <s/> as actual result for `control-flow/while-sum`.
+
+    3.  *for-order*: Set <s></s>, then evaluate
+        `<for items="x y z"><s><s/>-<item/></for>`.
+        Record <s/> as actual result for `control-flow/for-order`.
+
+    4.  *while-break*: Set <i>1</i> and <hit></hit>, then evaluate
+        `<while condition="<i/> is less than or equal to 9">
+        if <i/> equals 4 set <hit/> to <i/> and <break/>,
+        else set <i/> to <i/> + 1
+        </while>`.
+        Record <hit/> as actual result for `control-flow/while-break`.
+
+    5.  *step-skip*: A `<step condition="[...]">[...]</step>` either expands
+        to its body (if condition evaluates to true) or to the empty string,
+        so what does `<step condition="42 is greater than 7">X</step>` expands into?
+        Record the result of this construct for `control-flow/step-skip`.
+
+    6.  *expand-subst*: With `<define name="foo">[<arg1/>:<content/>]</define>`,
+        evaluate `<expand name="foo" arg1="K">V</expand>`.
+        Record actual result for `control-flow/expand-subst`.
+
+    Set <cf-total/> to the number of control-flow probes above.
+
+4.  STEP 4: Probe Regex Matching
+
+    Execute *all* of the following regex probes (in the given order).
+    For each probe, record the *actual* result in <actuals/> under the
+    key `regex/<probe-name/>`. Do *not* compare to any expected value
+    here.
+
+    1.  *getopt-dash*: Does the string `-l foo` match the regexp `(^|\s)-`?
+        Record `yes` or `no` as actual result for `regex/getopt-dash`.
+
+    2.  *getopt-nodash*: Does the string `foo` match the regexp `(^|\s)-`?
+        Record `yes` or `no` as actual result for `regex/getopt-nodash`.
+
+    3.  *anchored-int*: Does `123` fully match `^\d+$`, and does `12a` fully
+        match `^\d+$`? Report as `<yes-or-no/>,<yes-or-no/>`.
+        Record actual result for `regex/anchored-int`.
+
+    4.  *alternation*: Does `thorough` match `^(basic|standard|thorough)$`?
+        Record `yes` or `no` as actual result for `regex/alternation`.
+
+    5.  *capture*: Apply `^--(\w+).+` to `--foo-bar-quux`.
+        Record the first capture group as actual result for `regex/capture`.
+
+    6.  *whitespace*: Does ` -x` (leading space then dash) match `(^|\s)-`
+        (the `\s` alternative)?
+        Record `yes` or `no` as actual result for `regex/whitespace`.
+
+    7.  *complex*: Does  `--level=(low|high)...` match
+        `^--([A-Za-z][A-Za-z0-9-]*)(?:\|-([A-Za-z]))?(?:=(\((.*)\)(\.\.\.)?|.*))?$`?
+        Record `yes` or `no` as actual result for `regex/complex`.
+
+    Set <re-total/> to the number of regex probes above.
+
+5.  STEP 5: Probe Arithmetic
+
+    Execute *all* of the following arithmetic probes (in the given
+    order). For each probe, record the *actual* result in <actuals/>
+    under the key `arithmetic/<probe-name/>`. Do *not* compare to any
+    expected value here.
+
+    1.  *increment*: With <n>7</n>, compute <n/> + 2.
+        Record actual result for `arithmetic/increment`.
+
+    2.  *product-sum*: Compute `4.00 * 1.00 + 2.00 * 0.50`.
+        Record actual result (as `X.XX`) for `arithmetic/product-sum`.
+
+    3.  *percentage*: Compute `3 / 7` rounded to 2 decimal places.
+        Record actual result (as `0.XX`) for `arithmetic/percentage`.
+
+    4.  *bar-width*: With <title-len>13</title-len>, compute `67 - <title-len/>`.
+        Record actual result for `arithmetic/bar-width`.
+
+    5.  *threshold*: Is `0.095` less than `0.10`?
+        Record `yes` or `no` as actual result for `arithmetic/threshold`.
+
+    6.  *round-half*: Round `2.5` to the nearest integer (round half up).
+        Record actual result for `arithmetic/round-half`.
+
+    Set <arith-total/> to the number of arithmetic probes above.
+
+6.  STEP 6: Fetch Expected Values and Score
+
+    Call the `ase_compat()` tool of the `ase` MCP server with an
+    *internal* *programmatic* MCP tool call (and *NOT* with an external
+    shell command) and set <compat-output/> to the `text` content of the
+    response.
+
+    Parse <compat-output/> into a map <expected/> by splitting on
+    newlines; for each non-empty line of the form `<id/>: <value/>`, set
+    `<expected[<id/>]>` to `<value/>` (value may be empty for probes
+    whose correct answer is an empty string).
+
+    For each probe in <actuals/>, compare the actual result to
+    `<expected[<id/>]>` using an exact-match comparison:
+
+    -   If they match, count the probe as *pass*.
+    -   If they differ, count the probe as *fail* and append `<id/>`
+        to <failures/>.
+
+    Tally pass counts per category:
+
+    -   Set <xml-pass/>   to the number of `xml-placeholders/*` probes that passed.
+    -   Set <cf-pass/>    to the number of `control-flow/*`     probes that passed.
+    -   Set <re-pass/>    to the number of `regex/*`            probes that passed.
+    -   Set <arith-pass/> to the number of `arithmetic/*`       probes that passed.
+
+7.  STEP 7: Compute and Report Compatibility
+
+    Compute each category's *pass-rate* (a value in 0.0…1.0) by dividing
+    its passes by its total:
+
+    set <xml-rate/>   to <xml-pass/>   / <xml-total/>,
+    set <cf-rate/>    to <cf-pass/>    / <cf-total/>,
+    set <re-rate/>    to <re-pass/>    / <re-total/>,
+    set <arith-rate/> to <arith-pass/> / <arith-total/>.
+
+    Compute the overall compatibility as a *weighted average* of the
+    four pass-rates, where *XML placeholders* carry weight `4.00` (the
+    backbone of every skill), *control flow* carries weight `3.00`,
+    *regex matching* carries weight `2.00`, and *arithmetic* carries
+    weight `1.00`. Use the `ase_decision_matrix` MCP tool with a single
+    "compatibility" alternative column, one matrix row per category of
+    the form `[ <weight/>, <rate/> ]`:
+
+    Call...
+
+    `ase_decision_matrix(matrix: [
+        [ 4.00, <xml-rate/>   ],
+        [ 3.00, <cf-rate/>    ],
+        [ 2.00, <re-rate/>    ],
+        [ 1.00, <arith-rate/> ]
+    ])`
+
+    ...of the `ase` MCP server with an *internal* *programmatic* MCP
+    tool call (and *NOT* with an external shell command) and set
+    <product-sum/> to the *single* numerical value of the returned
+    array.
+
+    The product-sum is the sum over the four rows of `<weight/> *
+    <rate/>`, so dividing by the sum of weights (4.00 + 3.00 + 2.00 +
+    1.00 = 10.00) yields the weighted-average compatibility on 0.0…1.0:
+
+    Set <overall/> to <product-sum/> / 10.00.
+    Set <overall-pct/> to round(<overall/> * 100) (an integer percentage).
+
+    Also compute each category's display percentage:
+
+    Set <cf-pct/> to round(<cf-rate/> * 100), and
+    likewise <xml-pct/>, <re-pct/>, <arith-pct/>.
+
+    Determine the <verdict/> from <overall-pct/>:
+
+    1.  If <overall-pct/> is greater than or equal to 90:
+        Set <verdict>✓ *FULLY COMPATIBLE*</verdict>.
+
+    2.  Else if <overall-pct/> is greater than or equal to 60:
+        Set <verdict>⚠ *PARTIALLY COMPATIBLE*</verdict>.
+
+    3.  Else:
+        Set <verdict>✘ *INCOMPATIBLE*</verdict>.
+
+    4.  If <failures/> is not empty:
+        Append to <verdict/> the suffix ` (failed: <failures/>)`.
+
+    Finally, output the compatibility report:
+
+    **RESULTS**:
+
+    | ⦿ *Capability*       | ⚖ *Weight*  | ✓ *Passed*                   | ⚑ *Rate*            |
+    | :------------------- | ----------: | ---------------------------: | ------------------: |
+    | XML Placeholders     |        4.00 | <xml-pass/>/<xml-total/>     | <xml-pct/>%         |
+    | Control Flow         |        3.00 | <cf-pass/>/<cf-total/>       | <cf-pct/>%          |
+    | Regex Matching       |        2.00 | <re-pass/>/<re-total/>       | <re-pct/>%          |
+    | Arithmetic           |        1.00 | <arith-pass/>/<arith-total/> | <arith-pct/>%       |
+    | **OVERALL**          |             |                              | **<overall-pct/>%** |
+
+    **VERDICT**: <verdict/>

package/plugin/skills/ase-meta-compat/help.md

@@ -0,0 +1,67 @@
+
+##  NAME
+
+`ase-meta-compat` - Self-Test ASE Compatibility
+
+##  SYNOPSIS
+
+`ase-meta-compat`
+    [`--help`|`-h`]
+
+##  DESCRIPTION
+
+The `ase-meta-compat` skill *self-tests* how faithfully the current LLM
+(and its harness) executes the four *core interpreter primitives* that
+every ASE skill silently relies on, and reports an overall *0%…100%
+compatibility* rating. ASE skills are not run by a conventional
+interpreter - they are interpreted by the *model itself*, which must honor
+control-flow constructs, substitute XML placeholders, evaluate regex
+conditions, and perform arithmetic. If a model cannot execute these
+primitives reliably, *every* ASE skill silently misbehaves, so this skill
+lets a user measure the fit *before* relying on ASE.
+
+The skill is both the *test definition* and the *system under test*. It
+probes four capability categories:
+
+- *XML Placeholders*: the get (`<x/>`) and set (`<x>v</x>`) semantics,
+  including the get-and-set composite, indexed names, and XML-entity
+  rendering.
+
+- *Control Flow*: the `<if>`/`<elseif>`/`<else>`, `<while>`/`<break>`,
+  `<for>`, `<step condition=…>`, and `<expand>`/`<define>` constructs.
+
+- *Regex Matching*: the patterns ASE genuinely uses (e.g. the getopt
+  short-circuit `(^|\s)-`), plus anchoring, alternation, and captures.
+
+- *Arithmetic*: counter increments, decision-matrix product-sums,
+  percentage rounding, and bar-width computations.
+
+Each *probe* embeds a construct with a *known expected result*; the model
+executes it and honestly self-checks its actual result against the
+expected one. Per-category pass-rates are combined into the overall rating
+via the `ase_decision_matrix` MCP tool as a *weighted average*, with
+*XML Placeholders* weighted `4.00` (the backbone of every skill),
+*Control Flow* weighted `3.00`, *Regex Matching* weighted `2.00`, and
+*Arithmetic* weighted `1.00`. The
+result is a boxed per-category table (passes and percentage per category),
+a final *OVERALL COMPATIBILITY* percentage, and a one-line *VERDICT*
+(`✓ fully compatible` at `≥ 90%`, `⚠ partially compatible` at `60–89%`,
+`✘ incompatible` below `60%`) that names any failed probes.
+
+##  ARGUMENTS
+
+The `ase-meta-compat` skill takes no arguments (besides `--help`|`-h`). It
+always runs the most rigorous self-test, with 6 *probes per category*
+(7 for *Regex Matching*), for 25 probes in total.
+
+##  EXAMPLES
+
+Run the compatibility self-test:
+
+```text
+❯ /ase-meta-compat
+```
+
+##  SEE ALSO
+
+[`ase-meta-evaluate`](../ase-meta-evaluate/help.md), [`ase-meta-quorum`](../ase-meta-quorum/help.md), [`ase-meta-why`](../ase-meta-why/help.md).

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>
@@ -217,29 +219,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:

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

@@ -142,9 +142,9 @@ by querying *multiple* AIs for an *optimal consensus*.
     set <disagreement/> to `(no quorum: no foreign AIs were available)`,
     then skip the rest of this step.
 
-    Otherwise, determine, on a Likert scale of 0..<n/>, the amount of the
-    overall consensus <c/> of all the responses. The <n/> is the *total
-    number of responders* (yourself plus all available foreign AIs above).
+    Otherwise, let <n/> be the *total number of responders* (yourself plus
+    all available foreign AIs above). Then determine, on a Likert scale of
+    0..<n/>, the amount of the overall consensus <c/> of all the responses.
     If all responses disagree, the consensus <c/> is zero.
     If all responses agree, <c/> is <n/>.
 

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

@@ -93,6 +93,12 @@ 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/>'">
+        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).
+        </if>
+
         Only output the following <template/>:
 
         <template>

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

@@ -171,7 +171,11 @@ Set <content-dirty>true</content-dirty>.
 
     1.  Determine any existing plan content:
 
-        <if condition="<getopt-option-int-reuse-task/> is equal `true`">
+        <if condition="
+            <getopt-option-int-reuse-task/> is equal `true`
+            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
+            exists earlier in the current session
+        ">
             Set <text/> to the `text` argument of the most recent
             `ase_task_save(id: '<ase-task-id/>', ...)` tool call,
             *without* calling `ase_task_load` again. Set <status>plan
@@ -286,7 +290,7 @@ Set <content-dirty>true</content-dirty>.
             </template>
         </if>
 
-    4.  <if condition="<content/> does not contain '#   TASK' AND <instruction/> is empty">
+    4.  <if condition="no line of <content/> matches the case-insensitive regex `^\s*#+\s*TASK\b` AND <instruction/> is empty">
         Set <instruction><content/></instruction> (set instruction to content).
         Set <content></content> (set content to empty).
         Set <content-dirty>true</content-dirty>.

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

@@ -80,7 +80,11 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     1.  Determine the current task plan content:
 
-        <if condition="<getopt-option-int-reuse-task/> is equal `true`">
+        <if condition="
+            <getopt-option-int-reuse-task/> is equal `true`
+            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
+            exists earlier in the current session
+        ">
             Set <text/> to the `text` argument of the most recent
             `ase_task_save(id: '<ase-task-id/>', ...)` tool call,
             *without* calling `ase_task_load` again. Set <status>plan
@@ -105,12 +109,11 @@ explicitly requested by this procedure via outputs based on a <template/>!
         -   If <text/> starts NOT with `ERROR:` and NOT with `WARNING:`:
             Set <plan><text/></plan> (set plan to text).
             Calculate the number of words <words/> of <plan/>.
+            Then output the following <template/>:
 
-        Output the following <template/>:
-
-        <template>
-        ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
-        </template>
+            <template>
+            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ✪ plan: **<words/>** words, ▶ status: **<status/>**
+            </template>
 
     2.  <if condition="<plan/> is empty">
         Complain and tell the user to use the `ase-code-resolve`,
@@ -195,7 +198,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
                 <expand name="custom-dialog" arg1="--other">
                     <aspect-N/>: <question-N/>
-                    <answer-N-1-label/>: ⚝ **CURRENT PLAN** ⚝ <answer-N-1-description/>
+                    <answer-N-1-label/>: ⚝ **CURRENT PLAN** ⚝ - <answer-N-1-description/>
                     <answer-N-K-label/>: <answer-N-K-description/>
                     [...]
                 </expand>

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

@@ -52,9 +52,9 @@ Configure Task Id
     </if>
 
 4.  <if condition="<request/> is NOT empty">
-    -   Set <ase-task-id><request/></ase-task-id> and
-        call the `ase_task_id(id: "<ase-task-id/>", session: "<ase-session-id/>")`
-        tool from the `ase` MCP server.
+    -   Call the `ase_task_id(id: "<request/>", session: "<ase-session-id/>")`
+        tool from the `ase` MCP server. Check the response as mandated
+        above; only on a clean response set <ase-task-id><request/></ase-task-id>.
 
     -   Output:
         <template>

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

@@ -97,7 +97,11 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     1.  Determine the current task plan content:
 
-        <if condition="<getopt-option-int-reuse-task/> is equal `true`">
+        <if condition="
+            <getopt-option-int-reuse-task/> is equal `true`
+            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
+            exists earlier in the current session
+        ">
             Set <text/> to the `text` argument of the most recent
             `ase_task_save(id: '<ase-task-id/>', ...)` tool call,
             *without* calling `ase_task_load` again. Set <status>plan
@@ -210,7 +214,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
             skill accepts only an optional `[<id>]` argument and no
             `--next` option; remaining tokens are intentionally discarded.
             Only output the following <template/> and then call the
-            tool `Skill(skill: "ase:ase-task-delete", args: <args/>)`
+            tool `Skill(skill: "ase:ase-task-delete", args: "<args/>")`
             to invoke the `ase:ase-task-delete` skill in order to
             *delete* the updated plan. Immediately stop processing the
             current skill once the `Skill` tool was used.

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

@@ -97,7 +97,11 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     1.  Determine the current task plan content:
 
-        <if condition="<getopt-option-int-reuse-task/> is equal `true`">
+        <if condition="
+            <getopt-option-int-reuse-task/> is equal `true`
+            *and* a `ase_task_save(id: '<ase-task-id/>', ...)` tool call
+            exists earlier in the current session
+        ">
             Set <text/> to the `text` argument of the most recent
             `ase_task_save(id: '<ase-task-id/>', ...)` tool call,
             *without* calling `ase_task_load` again. Set <status>plan

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

@@ -71,6 +71,15 @@ explicitly requested by this procedure via outputs based on a <template/>!
         </template>
         </if>
 
+    6.  <if condition="<old/> is equal <new/>">
+        Only output the following <template/> and then immediately
+        *STOP* processing the entire current skill:
+
+        <template>
+        ⧉ **ASE**: ◉ task: **<old/>**, ▶ status: **task unchanged (old and new task id are equal)**
+        </template>
+        </if>
+
 2.  **Perform Operation**:
 
     1.  Call the `ase_task_rename(old: "<old/>", new: "<new/>")` tool of the