@rse/ase 0.9.11 → 0.9.12

package/dst/ase-compat.js

@@ -0,0 +1,68 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+/*  the canonical expected values for every ase-meta-compat probe,
+    keyed by "<category>/<probe-name>" as used in the skill  */
+const EXPECTED = {
+    /*  xml-placeholders  */
+    "xml-placeholders/get-and-set": "42",
+    "xml-placeholders/self-ref": "pre_42",
+    "xml-placeholders/overwrite": "99",
+    "xml-placeholders/indexed": "+1,-1",
+    "xml-placeholders/nested-attr": "20",
+    "xml-placeholders/entity": "○",
+    /*  control-flow  */
+    "control-flow/branch": "mid",
+    "control-flow/while-sum": "15",
+    "control-flow/for-order": "-x-y-z",
+    "control-flow/while-break": "4",
+    "control-flow/step-skip": "X",
+    "control-flow/expand-subst": "[K:V]",
+    /*  regex  */
+    "regex/getopt-dash": "yes",
+    "regex/getopt-nodash": "no",
+    "regex/anchored-int": "yes,no",
+    "regex/alternation": "yes",
+    "regex/capture": "foo",
+    "regex/whitespace": "yes",
+    "regex/complex": "yes",
+    /*  arithmetic  */
+    "arithmetic/increment": "9",
+    "arithmetic/product-sum": "5.00",
+    "arithmetic/percentage": "0.43",
+    "arithmetic/bar-width": "54",
+    "arithmetic/threshold": "yes",
+    "arithmetic/round-half": "3"
+};
+/*  format the expected values as "<id>: <value>\n" lines  */
+const formatExpected = () => Object.entries(EXPECTED).map(([id, value]) => `${id}: ${value}`).join("\n") + "\n";
+/*  CLI command "ase compat"  */
+export default class CompatCommand {
+    register(program) {
+        program
+            .command("compat")
+            .description("Output expected probe values for the ase-meta-compat self-test skill")
+            .action(() => {
+            process.stdout.write(formatExpected());
+        });
+    }
+}
+/*  MCP tool "ase_compat" — lets the skill call this without a Bash tool  */
+export class CompatMCP {
+    register(mcp) {
+        mcp.registerTool("ase_compat", {
+            title: "ASE compat expected values",
+            description: "Return the canonical expected probe values for the ase-meta-compat " +
+                "self-test skill as \"<id>: <value>\" lines, one per probe. " +
+                "Call this AFTER recording all actual probe results so the LLM " +
+                "cannot see the expected values before running the probes.",
+            inputSchema: {}
+        }, async () => {
+            return {
+                content: [{ type: "text", text: formatExpected() }]
+            };
+        });
+    }
+}

package/dst/ase-hook.js

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import os from "node:os";
 import { execaSync } from "execa";
 import { quote } from "shell-quote";
+import getStdin from "get-stdin";
 import * as v from "valibot";
 import Version from "./ase-version.js";
 import { Config, configSchema, parseScope } from "./ase-config.js";
@@ -41,7 +42,8 @@ const toolSpecs = {
         mcpToolNamePattern: /^mcp__plugin_ase_ase__.+/,
         addonMcpToolNamePattern: addonMcpToolNamePattern("mcp__", "__.+"),
         preToolUseWrapped: true,
-        preToolUseEvent: "PreToolUse"
+        preToolUseEvent: "PreToolUse",
+        approvalEvent: "PreToolUse"
     },
     "copilot": {
         toolNameField: "toolName",
@@ -51,7 +53,19 @@ const toolSpecs = {
         mcpToolNamePattern: /^ase-.+/,
         addonMcpToolNamePattern: addonMcpToolNamePattern("", "-.+"),
         preToolUseWrapped: false,
-        preToolUseEvent: "preToolUse"
+        preToolUseEvent: "preToolUse",
+        approvalEvent: "PreToolUse"
+    },
+    "codex": {
+        toolNameField: "tool_name",
+        toolInputField: "tool_input",
+        toolInputIsString: false,
+        bashToolName: "Bash",
+        mcpToolNamePattern: /^mcp__ase__.+/,
+        addonMcpToolNamePattern: addonMcpToolNamePattern("mcp__", "__.+"),
+        preToolUseWrapped: true,
+        preToolUseEvent: "PreToolUse",
+        approvalEvent: "PermissionRequest"
     }
 };
 /*  CLI command "ase hook"  */
@@ -64,6 +78,27 @@ export default class HookCommand {
     isValidSessionId(id) {
         return /^[A-Za-z0-9._-]+$/.test(id);
     }
+    /*  read the entire stdin payload asynchronously  */
+    readStdin() {
+        /*  best-effort: treat an unreadable/closed stdin as empty  */
+        return getStdin().catch(() => "");
+    }
+    /*  drain and discard the stdin event payload  */
+    async drainStdin() {
+        await this.readStdin();
+    }
+    /*  write to stdout and resolve only once it has been fully
+        flushed to the underlying file descriptor  */
+    writeStdout(text) {
+        return new Promise((resolve, reject) => {
+            process.stdout.write(text, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
     /*  best-effort JSON parse with valibot schema validation: returns
         an empty object on blank input, malformed JSON, or schema
         mismatch, so callers can treat the result uniformly. Extra
@@ -110,13 +145,24 @@ export default class HookCommand {
             return this.expandReferences(content, path.dirname(abs), next);
         });
     }
-    /*  handler for "ase hook session-start" (both tools)  */
+    /*  handler for "ase hook session-start" (all tools)  */
     async doSessionStart(tool) {
         /*  determine plugin root (env var name differs per tool)  */
-        const pluginRootVar = tool === "copilot" ? "COPILOT_PLUGIN_ROOT" : "CLAUDE_PLUGIN_ROOT";
-        const pluginRoot = process.env[pluginRootVar] ?? "";
+        let pluginRootVars;
+        if (tool === "copilot")
+            pluginRootVars = ["COPILOT_PLUGIN_ROOT"];
+        else if (tool === "codex")
+            pluginRootVars = ["PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"];
+        else
+            pluginRootVars = ["CLAUDE_PLUGIN_ROOT"];
+        let pluginRoot = "";
+        for (const pluginRootVar of pluginRootVars)
+            if ((process.env[pluginRootVar] ?? "") !== "") {
+                pluginRoot = process.env[pluginRootVar];
+                break;
+            }
         if (pluginRoot === "")
-            throw new Error(`${pluginRootVar} environment variable is not set`);
+            throw new Error(`${pluginRootVars.join("/")} environment variable is not set`);
         /*  determine path to external files  */
         const filePkg = path.join(pluginRoot, ".claude-plugin", "plugin.json");
         const fileMd = path.join(pluginRoot, "meta", "ase-constitution.md");
@@ -152,7 +198,7 @@ export default class HookCommand {
         const versionHint = versionHints.length > 0 ? "(" + versionHints.join(", ") + ")" : "";
         /*  read session information (Claude Code uses snake_case fields,
             Copilot CLI uses camelCase fields)  */
-        const stdin = fs.readFileSync(0, "utf8");
+        const stdin = await this.readStdin();
         const input = this.parseJSON(stdin, v.object({
             session_id: v.optional(v.string()),
             sessionId: v.optional(v.string()),
@@ -228,9 +274,10 @@ export default class HookCommand {
         /*  expand all @<file> references manually  */
         md = this.expandReferences(md, path.dirname(fileMd));
         /*  inject markdown into session context.
-            Claude Code expects the context nested in "hookSpecificOutput";
-            Copilot CLI expects a flat top-level "additionalContext" field.  */
-        const payload = tool === "claude" ? {
+            Claude Code and OpenAI Codex CLI expect the context nested in
+            "hookSpecificOutput"; Copilot CLI expects a flat top-level
+            "additionalContext" field.  */
+        const payload = tool !== "copilot" ? {
             "hookSpecificOutput": {
                 "hookEventName": "SessionStart",
                 "additionalContext": md
@@ -238,7 +285,7 @@ export default class HookCommand {
         } : {
             "additionalContext": md
         };
-        process.stdout.write(JSON.stringify(payload));
+        await this.writeStdout(JSON.stringify(payload));
         return 0;
     }
     /*  publish the agent activity marker to tmux as a per-pane user
@@ -258,19 +305,21 @@ export default class HookCommand {
         }
     }
     /*  handler for "ase hook user-prompt-submit" (both tools)  */
-    doUserPromptSubmit(_tool) {
+    async doUserPromptSubmit(_tool) {
+        await this.drainStdin();
         this.writeAgentStatus("busy");
         return 0;
     }
     /*  handler for "ase hook stop" (both tools)  */
-    doStop(_tool) {
+    async doStop(_tool) {
+        await this.drainStdin();
         this.writeAgentStatus("ready");
         return 0;
     }
     /*  handler for "ase hook session-end" (both tools)  */
-    doSessionEnd(_tool) {
+    async doSessionEnd(_tool) {
         /*  determine session id  */
-        const sessionId = this.readSessionIdFromStdin();
+        const sessionId = await this.readSessionIdFromStdin();
         /*  remove the session directory ~/.ase/session/<id> (only for a valid sessionId)  */
         if (this.isValidSessionId(sessionId)) {
             const dir = path.join(os.homedir(), ".ase", "session", sessionId);
@@ -289,8 +338,8 @@ export default class HookCommand {
         return input.session_id ?? input.sessionId ?? "";
     }
     /*  read session id from stdin JSON payload  */
-    readSessionIdFromStdin() {
-        const stdin = fs.readFileSync(0, "utf8");
+    async readSessionIdFromStdin() {
+        const stdin = await this.readStdin();
         const input = this.parseJSON(stdin, v.object({
             session_id: v.optional(v.string()),
             sessionId: v.optional(v.string())
@@ -319,17 +368,12 @@ export default class HookCommand {
     /*  the edit-capable skills whose active state lets the pre-tool-use
         hook auto-approve subsequent "Edit" invocations  */
     editCapableSkills = ["ase-code-lint", "ase-docs-proofread"];
-    /*  handler for "ase hook pre-tool-use" (both tools)  */
-    doPreToolUse(tool) {
-        const spec = toolSpecs[tool];
-        /*  read tool invocation information  */
-        const stdin = fs.readFileSync(0, "utf8");
-        const input = this.parseJSON(stdin, v.looseObject({
-            session_id: v.optional(v.string()),
-            sessionId: v.optional(v.string())
-        }));
-        /*  determine whether to auto-approve the tool invocation
-            (field names and value shapes differ between tools)  */
+    /*  determine whether an ASE tool invocation described by the parsed
+        hook input should be auto-approved, and (if so) the human-readable
+        reason. The input field names and value shapes differ between
+        tools, but the decision logic is shared by the "pre-tool-use" and
+        "permission-request" handlers.  */
+    decideApproval(spec, input) {
         const toolName = typeof input[spec.toolNameField] === "string" ?
             input[spec.toolNameField] : "";
         let toolInput = {};
@@ -341,32 +385,43 @@ export default class HookCommand {
             }));
         else if (!spec.toolInputIsString && typeof rawInput === "object" && rawInput !== null)
             toolInput = rawInput;
-        let approve = false;
-        let reason = "";
-        if (toolName === spec.bashToolName && /^ase(\s|$)/.test(toolInput.command ?? "")) {
-            approve = true;
-            reason = "ASE CLI invocation auto-approved";
-        }
-        else if (toolName === "Skill" && /^(?:ase:)?ase-.+/.test(toolInput.skill ?? "")) {
-            approve = true;
-            reason = "ASE skill invocation auto-approved";
-        }
-        else if (spec.mcpToolNamePattern.test(toolName)) {
-            approve = true;
-            reason = "ASE MCP tool invocation auto-approved";
-        }
-        else if (spec.addonMcpToolNamePattern.test(toolName)) {
-            approve = true;
-            reason = "ASE addon MCP tool invocation auto-approved";
-        }
+        if (toolName === spec.bashToolName && /^ase(\s|$)/.test(toolInput.command ?? ""))
+            return { approve: true, reason: "ASE CLI invocation auto-approved" };
+        else if (toolName === "Skill" && /^(?:ase:)?ase-.+/.test(toolInput.skill ?? ""))
+            return { approve: true, reason: "ASE skill invocation auto-approved" };
+        else if (spec.mcpToolNamePattern.test(toolName))
+            return { approve: true, reason: "ASE MCP tool invocation auto-approved" };
+        else if (spec.addonMcpToolNamePattern.test(toolName))
+            return { approve: true, reason: "ASE addon MCP tool invocation auto-approved" };
         else if (toolName === "Edit") {
             const sessionId = this.pickSessionId(input);
             const activeSkill = this.readActiveSkill(sessionId);
-            if (this.editCapableSkills.includes(activeSkill)) {
-                approve = true;
-                reason = `${activeSkill}: edit auto-approved for active edit-capable skill`;
-            }
+            if (this.editCapableSkills.includes(activeSkill))
+                return { approve: true, reason: `${activeSkill}: edit auto-approved for active edit-capable skill` };
         }
+        return { approve: false, reason: "" };
+    }
+    /*  handler for "ase hook pre-tool-use" (all tools).
+        For Claude Code and Copilot CLI this is where ASE tool
+        invocations are auto-approved (via "permissionDecision: allow").
+        OpenAI Codex CLI rejects that mechanism in "PreToolUse", so for
+        Codex this handler stays silent and approval is granted in the
+        separate "permission-request" handler instead -- the handler must
+        still drain stdin, as Codex treats a non-draining hook as a hard
+        error.  */
+    async doPreToolUse(tool) {
+        const spec = toolSpecs[tool];
+        /*  read tool invocation information  */
+        const stdin = await this.readStdin();
+        const input = this.parseJSON(stdin, v.looseObject({
+            session_id: v.optional(v.string()),
+            sessionId: v.optional(v.string())
+        }));
+        /*  Codex auto-approves through "PermissionRequest", not here  */
+        if (spec.approvalEvent !== "PreToolUse")
+            return 0;
+        /*  determine whether to auto-approve the tool invocation  */
+        const { approve, reason } = this.decideApproval(spec, input);
         /*  emit permission decision (or stay silent to defer to default flow).
             Claude Code expects the decision nested in "hookSpecificOutput";
             Copilot CLI expects flat top-level fields.  */
@@ -381,14 +436,42 @@ export default class HookCommand {
                 "permissionDecision": "allow",
                 "permissionDecisionReason": reason
             };
-            process.stdout.write(JSON.stringify(payload));
+            await this.writeStdout(JSON.stringify(payload));
+        }
+        return 0;
+    }
+    /*  handler for "ase hook permission-request" (OpenAI Codex CLI only).
+        Codex fires this event only when a tool invocation would otherwise
+        require interactive user approval, and -- unlike "PreToolUse" --
+        honors an auto-approval here through "decision.behavior: allow".
+        Staying silent (or returning a non-approval) defers to Codex's
+        normal approval flow.  */
+    async doPermissionRequest(tool) {
+        const spec = toolSpecs[tool];
+        /*  read tool invocation information  */
+        const stdin = await this.readStdin();
+        const input = this.parseJSON(stdin, v.looseObject({
+            session_id: v.optional(v.string()),
+            sessionId: v.optional(v.string())
+        }));
+        /*  determine whether to auto-approve the tool invocation  */
+        const { approve } = this.decideApproval(spec, input);
+        /*  emit the Codex "PermissionRequest" approval decision  */
+        if (approve) {
+            const payload = {
+                "hookSpecificOutput": {
+                    "hookEventName": "PermissionRequest",
+                    "decision": { "behavior": "allow" }
+                }
+            };
+            await this.writeStdout(JSON.stringify(payload));
         }
         return 0;
     }
     /*  parse and validate the --tool option  */
     parseTool(value) {
-        if (value !== "claude" && value !== "copilot")
-            throw new Error(`invalid --tool value: "${value}" (expected "claude" or "copilot")`);
+        if (value !== "claude" && value !== "copilot" && value !== "codex")
+            throw new Error(`invalid --tool value: "${value}" (expected "claude", "copilot", or "codex")`);
         return value;
     }
     /*  register commands  */
@@ -408,41 +491,49 @@ export default class HookCommand {
         hookCmd
             .command("session-start")
             .description("handle SessionStart hook event")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (opts) => {
-            process.exit(await this.doSessionStart(this.parseTool(opts.tool)));
+            process.exitCode = await this.doSessionStart(this.parseTool(opts.tool));
         });
         /*  register CLI sub-command "ase hook session-end"  */
         hookCmd
             .command("session-end")
             .description("handle SessionEnd hook event")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
-            .action((opts) => {
-            process.exit(this.doSessionEnd(this.parseTool(opts.tool)));
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+            .action(async (opts) => {
+            process.exitCode = await this.doSessionEnd(this.parseTool(opts.tool));
         });
         /*  register CLI sub-command "ase hook pre-tool-use"  */
         hookCmd
             .command("pre-tool-use")
             .description("handle tool PreToolUse hook event")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
-            .action((opts) => {
-            process.exit(this.doPreToolUse(this.parseTool(opts.tool)));
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+            .action(async (opts) => {
+            process.exitCode = await this.doPreToolUse(this.parseTool(opts.tool));
+        });
+        /*  register CLI sub-command "ase hook permission-request"  */
+        hookCmd
+            .command("permission-request")
+            .description("handle tool PermissionRequest hook event (Codex CLI)")
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+            .action(async (opts) => {
+            process.exitCode = await this.doPermissionRequest(this.parseTool(opts.tool));
         });
         /*  register CLI sub-command "ase hook user-prompt-submit"  */
         hookCmd
             .command("user-prompt-submit")
             .description("handle UserPromptSubmit hook event (mark agent as busy)")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
-            .action((opts) => {
-            process.exit(this.doUserPromptSubmit(this.parseTool(opts.tool)));
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+            .action(async (opts) => {
+            process.exitCode = await this.doUserPromptSubmit(this.parseTool(opts.tool));
         });
         /*  register CLI sub-command "ase hook stop"  */
         hookCmd
             .command("stop")
             .description("handle Stop hook event (mark agent as ready)")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
-            .action((opts) => {
-            process.exit(this.doStop(this.parseTool(opts.tool)));
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+            .action(async (opts) => {
+            process.exitCode = await this.doStop(this.parseTool(opts.tool));
         });
     }
 }

package/dst/ase-service.js

@@ -16,6 +16,7 @@ import * as v from "valibot";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { Config, configSchema, ConfigMCP } from "./ase-config.js";
+import { CompatMCP } from "./ase-compat.js";
 import { DiagramMCP } from "./ase-diagram.js";
 import { TaskMCP } from "./ase-task.js";
 import { MarkdownMCP } from "./ase-markdown.js";
@@ -236,6 +237,7 @@ export default class ServiceCommand {
         const buildMcpServer = () => {
             const mcp = new McpServer({ name: "ase", version: pkg.version });
             new ServiceMCP({ projectId: ctx.projectId, port: ctx.port, startTime }).register(mcp);
+            new CompatMCP().register(mcp);
             new DiagramMCP().register(mcp);
             new TaskMCP(this.log).register(mcp);
             new MarkdownMCP().register(mcp);

package/dst/ase-setup.js

@@ -13,8 +13,9 @@ import Table from "cli-table3";
 import chalk from "chalk";
 import Version from "./ase-version.js";
 const toolSpecs = {
-    "claude": { cli: "claude", label: "Claude Code" },
-    "copilot": { cli: "copilot", label: "Copilot CLI" }
+    "claude": { cli: "claude", label: "Claude Code", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
+    "copilot": { cli: "copilot", label: "Copilot CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
+    "codex": { cli: "codex", label: "OpenAI Codex CLI", pInstall: "add", pRemove: "remove", pUpdate: "upgrade" }
 };
 /*  CLI command "ase setup"  */
 export default class SetupCommand {
@@ -162,7 +163,7 @@ export default class SetupCommand {
         const pkgdir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
         const source = dev ? path.resolve(pkgdir, "..") : pkgdir;
         await this.run(spec.cli, ["plugin", "marketplace", "add", source]);
-        await this.run(spec.cli, ["plugin", "install", "ase@ase"], { retries: 3 });
+        await this.run(spec.cli, ["plugin", spec.pInstall, "ase@ase"], { retries: 3 });
         return 0;
     }
     /*  handler for "ase setup update" (both tools)  */
@@ -185,8 +186,8 @@ export default class SetupCommand {
                 but there is no version change in the plugin manifest,
                 so just re-install the plugin to let the tool update its copy  */
             this.log.write("info", `setup: update[dev]: re-install ASE ${spec.label} plugin (origin: local)`);
-            await this.run(spec.cli, ["plugin", "uninstall", "ase@ase"], { ignoreError: `ASE ${spec.label} plugin not installed` });
-            await this.run(spec.cli, ["plugin", "install", "ase@ase"], { retries: 3 });
+            await this.run(spec.cli, ["plugin", spec.pRemove, "ase@ase"], { ignoreError: `ASE ${spec.label} plugin not installed` });
+            await this.run(spec.cli, ["plugin", spec.pInstall, "ase@ase"], { retries: 3 });
         }
         else {
             /*  perform NPM version check  */
@@ -201,10 +202,17 @@ export default class SetupCommand {
             this.log.write("info", `setup: update: updating ASE CLI tool: ${current} -> ${latest}`);
             const updateCmd = await this.npmCmd(["update", "-g", "@rse/ase"], true);
             await this.run(updateCmd.cmd, updateCmd.args);
-            /*  update ASE plugin  */
+            /*  update ASE plugin (refresh the marketplace snapshot, then
+                update the plugin itself; the OpenAI Codex CLI has no
+                "plugin update" subcommand, so re-install it instead)  */
             this.log.write("info", `setup: update: updating ASE ${spec.label} plugin`);
-            await this.run(spec.cli, ["plugin", "marketplace", "update", "ase"]);
-            await this.run(spec.cli, ["plugin", "update", "ase@ase"]);
+            await this.run(spec.cli, ["plugin", "marketplace", spec.pUpdate, "ase"]);
+            if (tool !== "codex")
+                await this.run(spec.cli, ["plugin", "update", "ase@ase"]);
+            else {
+                await this.run(spec.cli, ["plugin", spec.pRemove, "ase@ase"], { ignoreError: `ASE ${spec.label} plugin not installed` });
+                await this.run(spec.cli, ["plugin", spec.pInstall, "ase@ase"], { retries: 3 });
+            }
         }
         return 0;
     }
@@ -213,9 +221,11 @@ export default class SetupCommand {
         const spec = toolSpecs[tool];
         await this.ensureTool(spec.cli);
         this.log.write("info", `setup: enable: enabling ASE ${spec.label} plugin`);
+        /*  the GitHub Copilot CLI and OpenAI Codex CLI have no "plugin
+            enable" subcommand, so (re-)install the plugin instead  */
         const args = tool === "claude" ?
             ["plugin", "enable", "ase@ase"] :
-            ["plugin", "install", "ase@ase"];
+            ["plugin", spec.pInstall, "ase@ase"];
         await this.run(spec.cli, args, { retries: tool === "claude" ? 1 : 3 });
         return 0;
     }
@@ -224,9 +234,11 @@ export default class SetupCommand {
         const spec = toolSpecs[tool];
         await this.ensureTool(spec.cli);
         this.log.write("info", `setup: disable: disabling ASE ${spec.label} plugin`);
+        /*  the GitHub Copilot CLI and OpenAI Codex CLI have no "plugin
+            disable" subcommand, so uninstall the plugin instead  */
         const args = tool === "claude" ?
             ["plugin", "disable", "ase@ase"] :
-            ["plugin", "uninstall", "ase@ase"];
+            ["plugin", spec.pRemove, "ase@ase"];
         await this.run(spec.cli, args, { retries: tool === "claude" ? 1 : 3 });
         return 0;
     }
@@ -242,7 +254,7 @@ export default class SetupCommand {
         /*  uninstall ASE plugin  */
         this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
             `uninstalling ASE ${spec.label} plugin (origin: ${dev ? "local" : "remote/bundled"})`);
-        await this.run(spec.cli, ["plugin", "uninstall", "ase@ase"], { ignoreError: `ASE ${spec.label} plugin not installed` });
+        await this.run(spec.cli, ["plugin", spec.pRemove, "ase@ase"], { ignoreError: `ASE ${spec.label} plugin not installed` });
         await this.run(spec.cli, ["plugin", "marketplace", "remove", "ase"], { ignoreError: `ASE ${spec.label} plugin marketplace not registered` });
         /*  uninstall ASE CLI tool (non-development only)  */
         if (!dev) {
@@ -349,7 +361,7 @@ export default class SetupCommand {
     /*  register an MCP server with the tool, supporting both the "stdio"
         (a local subprocess command) and "http" (a remote URL, optionally
         with HTTP headers) transports; the per-tool command line differs
-        between Claude Code and GitHub Copilot CLI  */
+        between Claude Code, GitHub Copilot CLI, and OpenAI Codex CLI  */
     async mcpAdd(tool, name, env, transport) {
         const args = ["mcp", "add"];
         if (tool === "claude") {
@@ -366,7 +378,7 @@ export default class SetupCommand {
                 args.push(name, transport.url);
             }
         }
-        else {
+        else if (tool === "copilot") {
             /*  GitHub Copilot CLI implies the stdio transport when the
                 command is provided after "--"; only "http"/"sse" servers
                 need an explicit "--transport" flag and take the URL as a
@@ -384,10 +396,27 @@ export default class SetupCommand {
                 args.push(name, transport.url);
             }
         }
+        else {
+            /*  OpenAI Codex CLI takes the server name as the first
+                positional argument and implies the stdio transport when the
+                command is provided after "--"; "http" servers take the URL
+                via the "--url" option (with optional "--header" flags)  */
+            if (transport.type === "stdio") {
+                args.push(name);
+                for (const [key, val] of Object.entries(env))
+                    args.push("--env", `${key}=${val}`);
+                args.push("--", ...transport.command);
+            }
+            else {
+                for (const [key, val] of Object.entries(transport.headers ?? {}))
+                    args.push("--header", `${key}: ${val}`);
+                args.push(name, "--url", transport.url);
+            }
+        }
         await this.run(toolSpecs[tool].cli, args);
     }
     /*  unregister an MCP server from the tool; the per-tool command line
-        differs between Claude Code and GitHub Copilot CLI  */
+        differs between Claude Code, GitHub Copilot CLI, and OpenAI Codex CLI  */
     async mcpRemove(tool, name) {
         const args = tool === "claude" ?
             ["mcp", "remove", "--scope", "user", name] :
@@ -527,8 +556,8 @@ export default class SetupCommand {
     ];
     /*  parse and validate the --tool option  */
     parseTool(value) {
-        if (value !== "claude" && value !== "copilot")
-            throw new Error(`invalid --tool value: "${value}" (expected "claude" or "copilot")`);
+        if (value !== "claude" && value !== "copilot" && value !== "codex")
+            throw new Error(`invalid --tool value: "${value}" (expected "claude", "copilot", or "codex")`);
         return value;
     }
     /*  register commands  */
@@ -551,7 +580,7 @@ export default class SetupCommand {
         setupCmd
             .command("install")
             .description("install the ASE plugin for a tool")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .option("-d, --dev", "use local working copy instead of remote/bundled repository", devDflt)
             .action(async (opts) => {
             process.exit(await this.doInstall(this.parseTool(opts.tool), opts.dev));
@@ -560,7 +589,7 @@ export default class SetupCommand {
         setupCmd
             .command("update")
             .description("update the ASE tool and the ASE plugin for a tool")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .option("-f, --force", "always perform the update, even if already at latest version", false)
             .option("-d, --dev", "use local working copy instead of remote/bundled repository", devDflt)
             .action(async (opts) => {
@@ -570,7 +599,7 @@ export default class SetupCommand {
         setupCmd
             .command("uninstall")
             .description("uninstall the ASE plugin for a tool and the ASE tool")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .option("-d, --dev", "use local working copy instead of remote/bundled repository", devDflt)
             .action(async (opts) => {
             process.exit(await this.doUninstall(this.parseTool(opts.tool), opts.dev));
@@ -579,7 +608,7 @@ export default class SetupCommand {
         setupCmd
             .command("enable")
             .description("enable the ASE plugin for a tool")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (opts) => {
             process.exit(await this.doEnable(this.parseTool(opts.tool)));
         });
@@ -587,7 +616,7 @@ export default class SetupCommand {
         setupCmd
             .command("disable")
             .description("disable the ASE plugin for a tool")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (opts) => {
             process.exit(await this.doDisable(this.parseTool(opts.tool)));
         });
@@ -610,7 +639,7 @@ export default class SetupCommand {
         mcpCmd
             .command("activate [servers]")
             .description("activate pre-defined MCP servers (comma-separated list, or \"all\")")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (servers, opts) => {
             process.exit(await this.doMcp("activate", this.parseTool(opts.tool), servers ?? "all"));
         });
@@ -618,7 +647,7 @@ export default class SetupCommand {
         mcpCmd
             .command("deactivate [servers]")
             .description("deactivate pre-defined MCP servers (comma-separated list, or \"all\")")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
             .action(async (servers, opts) => {
             process.exit(await this.doMcp("deactivate", this.parseTool(opts.tool), servers ?? "all"));
         });

package/dst/ase-statusline.js

@@ -184,8 +184,8 @@ export default class StatuslineCommand {
     }
     /*  parse and validate the --tool option  */
     parseTool(value) {
-        if (value !== "claude" && value !== "copilot")
-            throw new InvalidArgumentError(`invalid --tool value: "${value}" (expected "claude" or "copilot")`);
+        if (value !== "claude" && value !== "copilot" && value !== "codex")
+            throw new InvalidArgumentError(`invalid --tool value: "${value}" (expected "claude", "copilot", or "codex")`);
         return value;
     }
     /*  register commands  */
@@ -196,7 +196,7 @@ export default class StatuslineCommand {
         program
             .command("statusline")
             .description("Render Claude Code or GitHub Copilot CLI statusline from stdin JSON")
-            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\")", toolDflt)
+            .option("-t, --tool <tool>", "target tool (\"claude\" or \"copilot\"; \"codex\" is unsupported)", toolDflt)
             .option("-w, --width <n>", "force terminal width to <n> characters (0 = auto-detect via /dev/tty)", parseInteger("--width"), 0)
             .option("-m, --margin <n>", "reduce maximum used terminal width by <n> characters on each side", parseInteger("--margin"), 2)
             .option("--no-icons", "disable icons in placeholder rendering")
@@ -208,6 +208,10 @@ export default class StatuslineCommand {
             .action(async (lines, opts) => {
             /*  validate target tool  */
             const tool = this.parseTool(opts.tool);
+            /*  OpenAI Codex CLI has no scriptable custom statusline
+                mechanism, so reject the request explicitly  */
+            if (tool === "codex")
+                throw new Error("OpenAI Codex CLI does not support a custom statusline");
             /*  read all of stdin  */
             const input = await readStdin();
             /*  parse JSON data  */

package/dst/ase.js

@@ -15,6 +15,7 @@ import SetupCommand from "./ase-setup.js";
 import StatuslineCommand from "./ase-statusline.js";
 import TaskCommand from "./ase-task.js";
 import ArtifactCommand from "./ase-artifact.js";
+import CompatCommand from "./ase-compat.js";
 import pkg from "../package.json" with { type: "json" };
 /*  globally initialize logger  */
 const log = new Log("ase", "warning", "-");
@@ -51,6 +52,7 @@ const main = async () => {
     new StatuslineCommand(log).register(program);
     new TaskCommand(log).register(program);
     new ArtifactCommand(log).register(program);
+    new CompatCommand().register(program);
     new DiagramCommand(log).register(program);
     /*  parse program arguments  */
     await program.parseAsync(process.argv);

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.11",
+    "version":                              "0.9.12",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -58,6 +58,7 @@
         "which":                            "7.0.0",
         "update-notifier":                  "7.3.1",
         "shell-quote":                      "1.8.4",
+        "get-stdin":                        "10.0.0",
         "proper-lockfile":                  "4.1.2",
         "write-file-atomic":                "8.0.0",
         "pacote":                           "21.5.1",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.11",
+    "version":     "0.9.12",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/.codex-plugin/mcp.json

@@ -0,0 +1,8 @@
+{
+    "mcpServers": {
+        "ase": {
+            "command": "ase",
+            "args":    [ "mcp" ]
+        }
+    }
+}

package/plugin/.codex-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+    "name":        "ase",
+    "version":     "0.9.12",
+    "description": "Agentic Software Engineering (ASE)",
+    "keywords":    [ "agentic", "software", "engineering" ],
+    "homepage":    "https://ase.tools",
+    "repository":  "https://github.com/rse/ase",
+    "license":     "GPL-3.0",
+    "author": {
+        "name":    "Dr. Ralf S. Engelschall",
+        "email":   "rse@engelschall.com",
+        "url":     "https://engelschall.com"
+    },
+    "skills":      "./skills/",
+    "hooks":       "./hooks/hooks-codex.json",
+    "mcpServers":  "./.codex-plugin/mcp.json"
+}

package/plugin/.github/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name":        "ase",
-    "version":     "0.9.11",
+    "version":     "0.9.12",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/hooks/hooks-codex.json

@@ -0,0 +1,67 @@
+{
+    "hooks": {
+        "SessionStart": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook session-start --tool codex",
+                        "statusMessage": "Loading ASE..."
+                    }
+                ]
+            }
+        ],
+        "SessionEnd": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook session-end --tool codex",
+                        "statusMessage": "Cleaning up ASE..."
+                    }
+                ]
+            }
+        ],
+        "PreToolUse": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook pre-tool-use --tool codex"
+                    }
+                ]
+            }
+        ],
+        "PermissionRequest": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook permission-request --tool codex",
+                        "statusMessage": "Approve ASE..."
+                    }
+                ]
+            }
+        ],
+        "UserPromptSubmit": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook user-prompt-submit --tool codex"
+                    }
+                ]
+            }
+        ],
+        "Stop": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "ase hook stop --tool codex"
+                    }
+                ]
+            }
+        ]
+    }
+}

package/plugin/meta/ase-dialog.md

@@ -9,6 +9,9 @@ User Dialog
 <if condition="<ase-agent-tool/> is 'copilot'">
     <user-dialog-tool>ask_user</user-dialog-tool>
 </if>
+<if condition="<ase-agent-tool/> is 'codex'">
+    <user-dialog-tool>none</user-dialog-tool>
+</if>
 
 <define name="user-dialog">
 
@@ -138,6 +141,23 @@ Let the *user interactively choose* an answer.
 
         </if>
 
+    -   <if condition="<ase-agent-tool/> is 'codex'">
+
+        OpenAI Codex CLI has *no* interactive user-dialog tool, so you
+        *MUST* *NOT* call any tool here. Instead, render the question and
+        answers as a custom Markdown dialog and let the user reply with a
+        free-text choice -- exactly as defined by the following expansion,
+        passing <spec/> as its question specification, and set <result/> to
+        the result of that custom dialog:
+
+        <expand name="custom-dialog" arg1="--other">
+            <spec/>
+        </expand>
+
+        Do not output anything in this step!
+
+        </if>
+
 </define>
 
 <define name="custom-dialog">

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "http://github.com/rse/ase",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "http://github.com/rse/ase/issues" },
-    "version":                              "0.9.11",
+    "version":                              "0.9.12",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

@@ -249,7 +249,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         a question with the following custom dialog, where per
         approach A<n/>, you determine an ultra brief summary
         <short-summary/> and then use the answer option `A<n/>:
-        ⚝ **RECOMMENDATION** ⚝: <short-summary/>` for your
+        ⚝ **RECOMMENDATION** ⚝ - <short-summary/>` for your
         recommended approach plus zero or more answer options `A<n/>:
         <short-summary/>` for all other approaches:
 

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

@@ -238,7 +238,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         a question with the following custom dialog, where per
         approach A<n/>, you determine an ultra brief summary
         <short-summary/> and then use the answer option `A<n/>:
-        ⚝ **RECOMMENDATION** ⚝: <short-summary/>` for your
+        ⚝ **RECOMMENDATION** ⚝ - <short-summary/>` for your
         recommended approach plus zero or more answer options `A<n/>:
         <short-summary/>` for all other approaches:
 

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

@@ -289,7 +289,7 @@ permitted way to persist artifacts is via `ase_task_save(...)`.
         a question with the following custom dialog, where per
         approach A<n/>, you determine an ultra brief summary
         <short-summary/> and then use the answer option `A<n/>:
-        ⚝ **RECOMMENDATION** ⚝: <short-summary/>` for your
+        ⚝ **RECOMMENDATION** ⚝ - <short-summary/>` for your
         recommended approach plus zero or more answer options `A<n/>:
         <short-summary/>` for all other approaches:
 

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

@@ -195,7 +195,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>