/ase-meta-compat

name: ase-meta-compat
argument-hint: "[--help|-h]"
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

If `$1` (the first token of the skill arguments) is equal to `-h` or `--help`, you *MUST* once output the following output <template/> and then *IMMEDIATELY* *STOP* the further skill processing:

<template> @${CLAUDE_SKILL_DIR}/help.md </template>

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; in particular, it does not include the usual meta skill information.

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/></s></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>` expand 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/>`. Rec