@rse/ase 0.9.10 → 0.9.12

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

@@ -0,0 +1,288 @@
+---
+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 `&#x25CB;` 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.
+
+    </step>
+
+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.
+
+    </step>
+
+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.
+
+    </step>
+
+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/>)`.
+
+    Output the final compatibility report with the following <template/>:
+
+    <template>
+
+    **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/>
+
+    </template>

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

@@ -120,7 +120,11 @@ to <getopt-option-count/>; if <getopt-option-count/> is *non-numeric* or
     Anti-Theses or Counter-Arguments until you EITHER have found at
     least <count/> Anti-Theses or Counter-Arguments with at least a rank
     of 7 OR you have already checked a total of <count/> x 5 Anti-Theses
-    or Counter-Arguments.
+    or Counter-Arguments. If the second condition is reached first and
+    fewer than <count/> Anti-Theses or Counter-Arguments reached a rank
+    of at least 7, nevertheless surface the <count/> highest-ranked ones
+    found so far, because <count/> is the *minimum* number of
+    Anti-Theses to surface.
 
     Then, for the top-<count/> highest-ranked Anti-Theses or
     Counter-Arguments, sort them by their rank from highest to lowest,

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

@@ -109,7 +109,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
         3.  For each discovered *intent group*, emit the following row
             <template/>, where <intent/> is the intent label, <changes/>
-            is the total number of lines changed per feature in format
+            is the total number of lines changed per intent group in format
             `+N/-M`, <files/> is the list of affected file references,
             and <description/> is a *brief* one-to-two-sentence
             narrative of what changed and why:

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

@@ -13,11 +13,16 @@ effort: high
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-meta-evaluate">
 Evaluate Alternatives
 </skill>
 
+<expand name="getopt" arg1="ase-meta-evaluate">
+    $ARGUMENTS
+</expand>
+
 <objective>
 *Evaluate* *alternatives* through a weighted
 multi-*criteria* decision matrix.
@@ -25,7 +30,7 @@ multi-*criteria* decision matrix.
 
 <flow>
 1.  <step id="STEP 1: Determine Reason">
-    -   From the <request>$ARGUMENTS</request>, try to derive the overall
+    -   From the <request><getopt-arguments/></request>, try to derive the overall
         reason <reason/> for the evaluation. If no such reason can be
         derived, assume <reason>generic comparison</reason>.
 
@@ -38,7 +43,7 @@ multi-*criteria* decision matrix.
     </step>
 
 2.  <step id="STEP 2: Determine Alternatives">
-    -   From the <request>$ARGUMENTS</request> derive the two or more
+    -   From the <request><getopt-arguments/></request> derive the two or more
         alternatives <alternative-K/> (K=1-N) the user wants to be
         evaluated. Do not output anything.
 
@@ -105,7 +110,7 @@ multi-*criteria* decision matrix.
     </step>
 
 3.  <step id="STEP 3: Derive Criteria">
-    -   From the <request>$ARGUMENTS</request>, try to derive the criteria
+    -   From the <request><getopt-arguments/></request>, try to derive the criteria
         <criteria-L/> (L=1-M) for the evaluation. Do not output anything.
 
     -   For each criterion <criteria-L/> (L=1-M), decide on its <weight-L/>
@@ -222,23 +227,26 @@ multi-*criteria* decision matrix.
         ⚠ *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:
+    -   Otherwise, 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
+        set with a small winning gap surfaces the all-negative warning rather
+        than being masked by the small-distance branch:
 
         <template>
         <ase-tpl-bullet-signal/> **BEST ALTERNATIVE**: ⚑ **<alternative-K/>**
-        ⚠ *ATTENTION: small distance to second best alternative!*
+        ⚠ *ATTENTION: all alternatives rate negatively; this is the least-bad choice, not a strong winner!*
         </template>
 
-    -   Otherwise, 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:
+    -   Otherwise, if <percentage/> is less than 0.10, stop the flow after
+        you output just the following <template/> and do not output anything
+        else:
 
         <template>
         <ase-tpl-bullet-signal/> **BEST ALTERNATIVE**: ⚑ **<alternative-K/>**
-        ⚠ *ATTENTION: all alternatives rate negatively; this is the least-bad choice, not a strong winner!*
+        ⚠ *ATTENTION: small distance to second best alternative!*
         </template>
 
     -   Otherwise (<percentage/> is greater than or equal to 0.10), output

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

@@ -15,18 +15,23 @@ effort: high
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-meta-persona">
 Persona Configuration
 </skill>
 
+<expand name="getopt" arg1="ase-meta-persona">
+    $ARGUMENTS
+</expand>
+
 <objective>
 *Configure* the *persona style* of the agent to adjust the communication
 style and token usage intensity.
 </objective>
 
 1.  Determine request:
-    <request>$ARGUMENTS</request>
+    <request><getopt-arguments/></request>
     Do not output anything.
 
 2.  <if condition="<request/> is empty">

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

@@ -134,9 +134,17 @@ by querying *multiple* AIs for an *optimal consensus*.
 
 4.  <step id="STEP 4: Determine Consensus Rating">
 
-    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).
+    First, count the number of *available foreign AIs* (those queried in
+    STEP 2 which did *not* return an `ERROR:` response). If this count is
+    *zero* -- i.e., every foreign AI errored out or none were reachable
+    and only yourself (Anthropic Claude) remains -- a quorum is *not*
+    possible. In this case, set <c></c> and <n></n> to empty and instead
+    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).
     If all responses disagree, the consensus <c/> is zero.
     If all responses agree, <c/> is <n/>.
 
@@ -165,6 +173,10 @@ by querying *multiple* AIs for an *optimal consensus*.
 
     **CONSENSUS RATE**: **<c/>/<n/>** <disagreement/>
 
+    When a quorum was *not* possible (see STEP 4), render this line
+    instead as just `**CONSENSUS RATE**: *n/a* <disagreement/>` (omitting
+    the `<c/>/<n/>` fraction), as a single AI cannot form a consensus.
+
     &#x25CB; **Anthropic Claude**:
     - [...]
     - [...]

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

@@ -142,7 +142,11 @@ to <getopt-option-count/>; if <getopt-option-count/> is *non-numeric* or
     more Pro-Theses or Supporting-Arguments until you EITHER have found
     at least <count/> Pro-Theses or Supporting-Arguments with at least a
     rank of 7 OR you have already checked a total of <count/> x 5
-    Pro-Theses or Supporting-Arguments.
+    Pro-Theses or Supporting-Arguments. If the second condition is
+    reached first and fewer than <count/> Pro-Theses or
+    Supporting-Arguments reached a rank of at least 7, nevertheless
+    surface the <count/> highest-ranked ones found so far, because
+    <count/> is the *minimum* number of Pro-Theses to surface.
 
     Then, for the top-<count/> highest-ranked Pro-Theses or
     Supporting-Arguments, sort them by their rank from highest to lowest,

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

@@ -12,11 +12,16 @@ effort: high
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-task-delete">
 Delete a Task Plan
 </skill>
 
+<expand name="getopt" arg1="ase-task-delete">
+    $ARGUMENTS
+</expand>
+
 <objective>
 *Delete* the task plan.
 </objective>
@@ -32,7 +37,7 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
 1.  **Determine Task:**
 
-    1.  Set <id>$ARGUMENTS</id> initially, with any leading and trailing
+    1.  Set <id><getopt-arguments/></id> initially, with any leading and trailing
         whitespace stripped.
         Inherit the always existing <ase-task-id/> from the current context.
         Inherit the always existing <ase-session-id/> from the current context.

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

@@ -175,14 +175,32 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
             2.  Check the code base and your world knowledge and
                 use this information to find *up to three* grounded
-                alternative answers <answer-N-K/> (K={2,3,4}).
-
-            3.  Use an interactive user dialog
-                with header <aspect-N/> and question <question-N/>, and
-                let the user select the <answer-N/> out of <answer-N-K/>
-                (K={1..4}). In this dialog, mark the <answer-N-1/> by
-                appending ` ⚝ **CURRENT PLAN** ⚝` to its option name (not the
-                description).
+                alternative answers <answer-N-K/> (K={2,3,4}), so there
+                are between two and four answer options in total.
+
+            3.  In the following, you *MUST* *NOT* use the
+                <user-dialog-tool/> tool! Instead, you *MUST* just show a
+                custom output, let the user enter input, and then you set
+                the result accordingly.
+
+                Let the user select the <answer-N/> out of the answer
+                alternatives <answer-N-K/> by raising a question with the
+                following custom dialog, where per alternative <answer-N-K/>
+                you determine a brief label <answer-N-K-label/> and a
+                description <answer-N-K-description/>, and you mark the
+                <answer-N-1/> by prefixing its description with
+                `⚝ **CURRENT PLAN** ⚝ `. Emit only the answer lines for the
+                alternatives <answer-N-K/> you actually determined in the
+                previous step (between two and four lines in total):
+
+                <expand name="custom-dialog" arg1="--other">
+                    <aspect-N/>: <question-N/>
+                    <answer-N-1-label/>: ⚝ **CURRENT PLAN** ⚝ - <answer-N-1-description/>
+                    <answer-N-K-label/>: <answer-N-K-description/>
+                    [...]
+                </expand>
+
+                Set <answer-N/> to the selected <result/>.
 
             4.  Output the following <template/>:
 
@@ -199,7 +217,10 @@ explicitly requested by this procedure via outputs based on a <template/>!
 
     4.  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. Then insert the current
+        <timestamp-modified/> information. If <timestamp-created/> is
+        still unset (because the previous <plan/> had no `Created:`
+        line), set <timestamp-created><timestamp-modified/></timestamp-created>
+        (fall back to the modified timestamp). Then insert the current
         <ase-task-id/>, previous <timestamp-created/>, and refreshed
         <timestamp-modified/> information and calculate the number of
         words <words/> of <plan/>.

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

@@ -12,17 +12,23 @@ effort: high
 
 @${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
 @${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
+@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md
 
 <skill name="ase-task-id">
 Configure Task Id
 </skill>
 
+<expand name="getopt" arg1="ase-task-id">
+    $ARGUMENTS
+</expand>
+
 <objective>
 *Get* or *set* the unique *task id* of the current session.
 </objective>
 
 1.  Determine request:
-    <request>$ARGUMENTS</request>
+    <request><getopt-arguments/></request>
+    Inherit the always existing <ase-session-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
@@ -35,8 +41,9 @@ Configure Task Id
 
 3.  <if condition="<request/> is empty">
     -   Call the `ase_task_id(session: "<ase-session-id/>")`
-        tool from the `ase` MCP server and set
-        <ase-task-id/> to its `text` output.
+        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>.
 
     -   Output:
         <template>