@rse/ase 0.9.31 → 0.9.33

package/dst/ase-artifact.js

@@ -10,6 +10,7 @@ import { isScalar } from "yaml";
 import { z } from "zod";
 import { Config, configSchema } from "./ase-config.js";
 import { Task } from "./ase-task.js";
+import { writeStdout } from "./ase-stdout.js";
 /*  the recognized artifact kinds, in descending precedence order;
     "othr" is the implicit catch-all and is always resolved last  */
 export const artifactKinds = ["spec", "arch", "code", "docs", "infr", "othr"];
@@ -223,17 +224,16 @@ export default class ArtifactCommand {
             .description("Resolve one or more artifact kinds to project-relative file paths")
             .option("--kind <kinds>", "comma-separated list of artifact kinds " +
             `(${artifactKinds.join("|")})`, artifactKinds.join(","))
-            .action((opts) => {
+            .action(async (opts) => {
             const kinds = opts.kind.split(",").map((k) => Artifact.validateKind(k.trim()));
             const result = Artifact.list(this.log, kinds);
             const single = result.length === 1;
             for (const { kind, files } of result) {
                 if (!single)
-                    process.stdout.write(`# ${kind}:\n`);
+                    await writeStdout(`# ${kind}:\n`);
                 for (const file of files)
-                    process.stdout.write(`- ${file}\n`);
+                    await writeStdout(`- ${file}\n`);
             }
-            process.exit(0);
         });
         /*  register CLI sub-command "ase artifact name"  */
         artifact
@@ -242,10 +242,9 @@ export default class ArtifactCommand {
             .argument("<filename>", "base-relative filename within the kind's basedir")
             .option("--kind <kind>", "artifact kind " +
             `(${configuredKinds.join("|")})`, "code")
-            .action((filename, opts) => {
+            .action(async (filename, opts) => {
             const kind = Artifact.validateKind(opts.kind.trim());
-            process.stdout.write(`${Artifact.name(this.log, kind, filename)}\n`);
-            process.exit(0);
+            await writeStdout(`${Artifact.name(this.log, kind, filename)}\n`);
         });
     }
 }

package/dst/ase-hook.js

@@ -12,6 +12,7 @@ import getStdin from "get-stdin";
 import * as v from "valibot";
 import Version from "./ase-version.js";
 import { Config, configSchema, parseScope } from "./ase-config.js";
+import { writeStdout } from "./ase-stdout.js";
 const addonMcpServers = [
     "chat-alibaba-qwen",
     "chat-deepseek",
@@ -24,8 +25,8 @@ const addonMcpServers = [
     "search-perplexity"
 ];
 /*  build a per-tool regular expression matching the tool names exposed
-    by the addon MCP servers: Claude Code prefixes them as
-    "mcp__<server>__<tool>", whereas Copilot CLI prefixes them as
+    by the addon MCP servers: Anthropic Claude Code CLI prefixes them as
+    "mcp__<server>__<tool>", whereas GitHub Copilot CLI prefixes them as
     "<server>-<tool>"  */
 const addonMcpToolNamePattern = (prefix, suffix) => {
     const alternatives = addonMcpServers
@@ -87,18 +88,6 @@ export default class HookCommand {
     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
@@ -145,9 +134,9 @@ export default class HookCommand {
             return this.expandReferences(content, path.dirname(abs), next);
         });
     }
-    /*  handler for "ase hook session-start" (all tools)  */
-    async doSessionStart(tool) {
-        /*  determine plugin root (env var name differs per tool)  */
+    /*  determine the plugin root directory (the environment variable
+        carrying it differs per tool), throwing if it cannot be found  */
+    pluginRoot(tool) {
         let pluginRootVars;
         if (tool === "copilot")
             pluginRootVars = ["COPILOT_PLUGIN_ROOT"];
@@ -163,6 +152,23 @@ export default class HookCommand {
             }
         if (pluginRoot === "")
             throw new Error(`${pluginRootVars.join("/")} environment variable is not set`);
+        return pluginRoot;
+    }
+    /*  determine the plugin root directory like "pluginRoot", but return
+        an empty string instead of throwing, so callers on the hot path of
+        a tool-approval decision can silently decline to auto-approve  */
+    pluginRootSafe(tool) {
+        try {
+            return this.pluginRoot(tool);
+        }
+        catch (_e) {
+            return "";
+        }
+    }
+    /*  handler for "ase hook session-start" (all tools)  */
+    async doSessionStart(tool) {
+        /*  determine plugin root (env var name differs per tool)  */
+        const pluginRoot = this.pluginRoot(tool);
         /*  determine path to external files  */
         const filePkg = path.join(pluginRoot, ".claude-plugin", "plugin.json");
         const fileMd = path.join(pluginRoot, "meta", "ase-constitution.md");
@@ -196,8 +202,8 @@ export default class HookCommand {
         if (process.env.ASE_SETUP_DEV !== undefined)
             versionHints.push("**NOTICE:** *development* setup");
         const versionHint = versionHints.length > 0 ? "(" + versionHints.join(", ") + ")" : "";
-        /*  read session information (Claude Code uses snake_case fields,
-            Copilot CLI uses camelCase fields)  */
+        /*  read session information (Anthropic Claude Code CLI uses snake_case fields,
+            GitHub Copilot CLI uses camelCase fields)  */
         const stdin = await this.readStdin();
         const input = this.parseJSON(stdin, v.object({
             session_id: v.optional(v.string()),
@@ -246,11 +252,12 @@ export default class HookCommand {
             persona = val;
         /*  determine headless mode  */
         const headless = (process.env.ASE_HEADLESS ?? "false") === "true" ? "true" : "false";
-        /*  provide ASE information to Claude Code shell commands
-            (Claude Code only -- Copilot CLI has no equivalent mechanism)  */
+        /*  provide ASE information to Anthropic Claude Code CLI shell commands
+            (Anthropic Claude Code CLI only -- GitHub Copilot CLI has no equivalent mechanism)  */
         const envFile = tool === "claude" ? (process.env.CLAUDE_ENV_FILE ?? "") : "";
         if (envFile !== "") {
             const script = `export ASE_VERSION=${quote([versionCurrentPlugin])}\n` +
+                `export ASE_PLUGIN_ROOT=${quote([pluginRoot])}\n` +
                 `export ASE_USER_ID=${quote([userId])}\n` +
                 `export ASE_PROJECT_ID=${quote([projectId])}\n` +
                 `export ASE_TASK_ID=${quote([taskId])}\n` +
@@ -263,6 +270,7 @@ export default class HookCommand {
         md =
             `<ase-version>${versionCurrentPlugin}</ase-version>\n` +
                 `<ase-version-hint>${versionHint}</ase-version-hint>\n` +
+                `<ase-plugin-root>${pluginRoot}</ase-plugin-root>\n` +
                 `<ase-persona-style>${persona}</ase-persona-style>\n` +
                 `<ase-user-id>${userId}</ase-user-id>\n` +
                 `<ase-project-id>${projectId}</ase-project-id>\n` +
@@ -276,15 +284,15 @@ export default class HookCommand {
         /*  build the deterministic ASE banner (rendered directly by the
             agent harness, independent of any model decision, so it is
             guaranteed to appear once in every non-headless session;
-            Claude Code and OpenAI Codex CLI surface a top-level
-            "systemMessage" field for this -- Copilot CLI has no equivalent)  */
+            Anthropic Claude Code CLI and OpenAI Codex CLI surface a top-level
+            "systemMessage" field for this -- GitHub Copilot CLI has no equivalent)  */
         const banner = `\n⧉ ASE: ⎈ version: ${versionCurrentPlugin}${versionHint !== "" ? " " + versionHint.replaceAll(/\*/g, "") : ""}` +
             `\n⧉ ASE: ※ user: ${userId}, ⚑ project: ${projectId}` +
             `\n⧉ ASE: ◉ task: ${taskId}, ⏻ session: ${sessionId}` +
             `\n⧉ ASE: ☯ persona: ${persona}`;
         /*  inject markdown into session context.
-            Claude Code and OpenAI Codex CLI expect the context nested in
-            "hookSpecificOutput"; Copilot CLI expects a flat top-level
+            Anthropic Claude Code CLI and OpenAI Codex CLI expect the context nested in
+            "hookSpecificOutput"; GitHub Copilot CLI expects a flat top-level
             "additionalContext" field.  */
         const payload = tool !== "copilot" ? {
             "hookSpecificOutput": {
@@ -299,14 +307,14 @@ export default class HookCommand {
             running headless -- mirroring the constitution box condition)  */
         if ((tool === "claude" || tool === "codex") && headless !== "true")
             payload.systemMessage = banner;
-        await this.writeStdout(JSON.stringify(payload));
+        await writeStdout(JSON.stringify(payload));
         return 0;
     }
     /*  publish the agent activity marker to tmux as a per-pane user
         option, so tmux can render the live state via
         #{@ase_agent_status} (refreshed on tmux's own interval,
-        independent of Claude Code's statusline repaint cadence).
-        Notice: the Claude Code statusline is not usable for this case
+        independent of Anthropic Claude Code CLI's statusline repaint cadence).
+        Notice: the Anthropic Claude Code CLI statusline is not usable for this case
         at all, as it is not repainted during agent processing!  */
     writeAgentStatus(status) {
         const icon = status === "busy" ? "▶" : "⏸";
@@ -346,8 +354,8 @@ export default class HookCommand {
         }
         return 0;
     }
-    /*  pick the session id from a parsed payload (Claude Code uses
-        snake_case fields, Copilot CLI uses camelCase fields)  */
+    /*  pick the session id from a parsed payload (Anthropic Claude Code CLI uses
+        snake_case fields, GitHub Copilot CLI uses camelCase fields)  */
     pickSessionId(input) {
         return input.session_id ?? input.sessionId ?? "";
     }
@@ -379,6 +387,23 @@ export default class HookCommand {
             return "";
         }
     }
+    /*  determine whether a "Read" target "filePath" resolves to a
+        location inside the plugin root, so the recurring loads of ASE
+        skill include files (e.g. "@${CLAUDE_SKILL_DIR}/../../meta/...")
+        can be auto-approved instead of prompting the user on every skill
+        invocation. The path is normalized and compared with a trailing
+        separator to prevent a sibling directory sharing the root's name
+        prefix (or a "../" escape) from being mistaken for a descendant.  */
+    isUnderPluginRoot(tool, filePath) {
+        if (filePath === "")
+            return false;
+        const pluginRoot = this.pluginRootSafe(tool);
+        if (pluginRoot === "")
+            return false;
+        const root = path.resolve(pluginRoot) + path.sep;
+        const abs = path.resolve(filePath);
+        return (abs + path.sep).startsWith(root);
+    }
     /*  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"];
@@ -387,7 +412,7 @@ export default class HookCommand {
         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) {
+    decideApproval(tool, spec, input) {
         const toolName = typeof input[spec.toolNameField] === "string" ?
             input[spec.toolNameField] : "";
         let toolInput = {};
@@ -395,7 +420,8 @@ export default class HookCommand {
         if (spec.toolInputIsString && typeof rawInput === "string")
             toolInput = this.parseJSON(rawInput, v.object({
                 command: v.optional(v.string()),
-                skill: v.optional(v.string())
+                skill: v.optional(v.string()),
+                file_path: v.optional(v.string())
             }));
         else if (!spec.toolInputIsString && typeof rawInput === "object" && rawInput !== null)
             toolInput = rawInput;
@@ -407,6 +433,8 @@ export default class HookCommand {
             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 === "Read" && this.isUnderPluginRoot(tool, toolInput.file_path ?? ""))
+            return { approve: true, reason: "ASE plugin file read auto-approved" };
         else if (toolName === "Edit") {
             const sessionId = this.pickSessionId(input);
             const activeSkill = this.readActiveSkill(sessionId);
@@ -416,7 +444,7 @@ export default class HookCommand {
         return { approve: false, reason: "" };
     }
     /*  handler for "ase hook pre-tool-use" (all tools).
-        For Claude Code and Copilot CLI this is where ASE tool
+        For Anthropic Claude Code CLI and GitHub 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
@@ -435,10 +463,10 @@ export default class HookCommand {
         if (spec.approvalEvent !== "PreToolUse")
             return 0;
         /*  determine whether to auto-approve the tool invocation  */
-        const { approve, reason } = this.decideApproval(spec, input);
+        const { approve, reason } = this.decideApproval(tool, 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.  */
+            Anthropic Claude Code CLI expects the decision nested in "hookSpecificOutput";
+            GitHub Copilot CLI expects flat top-level fields.  */
         if (approve) {
             const payload = spec.preToolUseWrapped ? {
                 "hookSpecificOutput": {
@@ -450,7 +478,7 @@ export default class HookCommand {
                 "permissionDecision": "allow",
                 "permissionDecisionReason": reason
             };
-            await this.writeStdout(JSON.stringify(payload));
+            await writeStdout(JSON.stringify(payload));
         }
         return 0;
     }
@@ -469,7 +497,7 @@ export default class HookCommand {
             sessionId: v.optional(v.string())
         }));
         /*  determine whether to auto-approve the tool invocation  */
-        const { approve } = this.decideApproval(spec, input);
+        const { approve } = this.decideApproval(tool, spec, input);
         /*  emit the Codex "PermissionRequest" approval decision  */
         if (approve) {
             const payload = {
@@ -478,7 +506,7 @@ export default class HookCommand {
                     "decision": { "behavior": "allow" }
                 }
             };
-            await this.writeStdout(JSON.stringify(payload));
+            await writeStdout(JSON.stringify(payload));
         }
         return 0;
     }
@@ -496,7 +524,7 @@ export default class HookCommand {
         /*  register CLI top-level command "ase hook"  */
         const hookCmd = program
             .command("hook")
-            .description("Claude Code and Copilot CLI hook entry points")
+            .description("Anthropic Claude Code CLI and GitHub Copilot CLI hook entry points")
             .action(() => {
             hookCmd.outputHelp();
             process.exit(1);

package/dst/ase-kv.js

@@ -7,7 +7,7 @@ import { z } from "zod";
 /*  reusable functionality: in-memory key/value store living inside the
     "ase service" process; per-project (one service per project) and
     not persisted; intended for sharing information between skills
-    across multiple Claude Code instances connected to the same service  */
+    across multiple Anthropic Claude Code CLI instances connected to the same service  */
 export class KV {
     /*  the actual in-memory store  */
     static store = new Map();

package/dst/ase-meta.js

@@ -0,0 +1,65 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { writeStdout } from "./ase-stdout.js";
+/*  reusable functionality: resolve and read plugin "meta/" files  */
+export class Meta {
+    /*  determine the plugin "meta/" directory; the build process copies
+        the sibling "plugin/" tree into the tool package (see the "copy
+        plugin directory into package for bundling" build step), so a
+        bundled "<pkgdir>/plugin/meta/" is always available right next to
+        the compiled tool, independent of any environment variables  */
+    static dir() {
+        const pkgdir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+        return path.join(pkgdir, "plugin", "meta");
+    }
+    /*  resolve a single requested meta name to an absolute path within
+        the "meta/" directory; the name is reduced to its basename to
+        reject path traversal and absolute paths, then expanded into the
+        canonical "ase-<name>.md" file name (the "ase-" prefix and ".md"
+        extension are added when not already present)  */
+    static resolve(name) {
+        let base = path.basename(name.replace(/\\/g, "/"));
+        if (base === "" || base === "." || base === "..")
+            throw new Error(`meta: invalid file name "${name}"`);
+        if (path.extname(base) === "")
+            base = `${base}.md`;
+        if (!base.startsWith("ase-"))
+            base = `ase-${base}`;
+        return path.join(Meta.dir(), base);
+    }
+    /*  read the contents of a single requested meta file  */
+    static read(name) {
+        const abs = Meta.resolve(name);
+        try {
+            return fs.readFileSync(abs, "utf8");
+        }
+        catch (_e) {
+            throw new Error(`meta: failed to read file: ${abs}`);
+        }
+    }
+}
+/*  CLI command "ase meta"  */
+export default class MetaCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register command  */
+    register(program) {
+        program
+            .command("meta")
+            .description("Output the contents of one or more plugin meta files")
+            .argument("<name...>", "meta file name(s) (\"ase-\" prefix and \".md\" extension optional)")
+            .action(async (names) => {
+            this.log.write("debug", `meta: reading ${names.length} file(s)`);
+            for (const name of names)
+                await writeStdout(Meta.read(name));
+        });
+    }
+}

package/dst/ase-setup.js

@@ -13,8 +13,8 @@ import Table from "cli-table3";
 import chalk from "chalk";
 import Version from "./ase-version.js";
 const toolSpecs = {
-    "claude": { cli: "claude", label: "Claude Code", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
-    "copilot": { cli: "copilot", label: "Copilot CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
+    "claude": { cli: "claude", label: "Anthropic Claude Code CLI", pInstall: "install", pRemove: "uninstall", pUpdate: "update" },
+    "copilot": { cli: "copilot", label: "GitHub 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"  */
@@ -361,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, GitHub Copilot CLI, and OpenAI Codex CLI  */
+        between Anthropic Claude Code CLI, GitHub Copilot CLI, and OpenAI Codex CLI  */
     async mcpAdd(tool, name, env, transport) {
         const args = ["mcp", "add"];
         if (tool === "claude") {
@@ -416,7 +416,7 @@ export default class SetupCommand {
         await this.run(toolSpecs[tool].cli, args);
     }
     /*  unregister an MCP server from the tool; the per-tool command line
-        differs between Claude Code, GitHub Copilot CLI, and OpenAI Codex CLI  */
+        differs between Anthropic Claude Code CLI, GitHub Copilot CLI, and OpenAI Codex CLI  */
     async mcpRemove(tool, name) {
         const args = tool === "claude" ?
             ["mcp", "remove", "--scope", "user", name] :

package/dst/ase-statusline.js

@@ -12,7 +12,7 @@ import { execaSync } from "execa";
 import { Chalk } from "chalk";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 import pkg from "../package.json" with { type: "json" };
-/*  forced-color chalk instance: stdout is a pipe under Claude Code,
+/*  forced-color chalk instance: stdout is a pipe under Anthropic Claude Code CLI,
     so chalk auto-detection would yield level 0; force level 1 to keep
     emitting ANSI sequences as the original implementation did  */
 const c = new Chalk({ level: 1 });
@@ -34,7 +34,7 @@ const readStdin = async () => {
         chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
     return Buffer.concat(chunks).toString("utf8");
 };
-/*  detect terminal column width via /dev/tty (stdout is a pipe under Claude Code)  */
+/*  detect terminal column width via /dev/tty (stdout is a pipe under Anthropic Claude Code CLI)  */
 const detectTermWidth = () => {
     let width = 0;
     let tty = null;
@@ -195,7 +195,7 @@ export default class StatuslineCommand {
         const toolDflt = envTool !== "" ? this.parseTool(envTool) : "claude";
         program
             .command("statusline")
-            .description("Render Claude Code or GitHub Copilot CLI statusline from stdin JSON")
+            .description("Render Anthropic Claude Code CLI or GitHub Copilot CLI statusline from stdin JSON")
             .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)
@@ -225,7 +225,7 @@ export default class StatuslineCommand {
                 process.exit(1);
             }
             /*  normalize Copilot CLI's top-level "cwd" into the
-                "workspace.current_dir" structure shared with Claude Code  */
+                "workspace.current_dir" structure shared with Anthropic Claude Code CLI  */
             if (tool === "copilot"
                 && (data.workspace?.current_dir === undefined || data.workspace.current_dir === "")
                 && typeof data.cwd === "string" && data.cwd !== "") {

package/dst/ase-stdout.js

@@ -0,0 +1,18 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+/*  write a string to stdout, awaiting the write callback which only
+    fires once the data has been flushed to the underlying pipe, so a
+    subsequent "process.exit" cannot truncate the output  */
+export const writeStdout = (text) => {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(text, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+};

package/dst/ase-task.js

@@ -12,6 +12,7 @@ import { isScalar } from "yaml";
 import { z } from "zod";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 import { Markdown } from "./ase-markdown.js";
+import { writeStdout } from "./ase-stdout.js";
 /*  reusable functionality: persisted task plans under
     <project>/<basedir>/TASK-<id>.md (driven by the
     "project.artifact.task.{basedir,files}" configuration)  */
@@ -269,25 +270,23 @@ export default class TaskCommand {
             .command("list")
             .description("List all persisted task ids, one per line")
             .option("-v, --verbose", "also show the task file modification time as (YYYY-MM-DD HH:MM)")
-            .action((opts) => {
+            .action(async (opts) => {
             const items = Task.list(this.log, opts.verbose ?? false);
             for (const item of items) {
                 if (opts.verbose)
-                    process.stdout.write(`${item.id}\t(${item.mtime})\n`);
+                    await writeStdout(`${item.id}\t(${item.mtime})\n`);
                 else
-                    process.stdout.write(`${item.id}\n`);
+                    await writeStdout(`${item.id}\n`);
             }
-            process.exit(0);
         });
         /*  register CLI sub-command "ase task load"  */
         task
             .command("load")
             .description("Load a task by id and write it to stdout")
             .argument("<id>", "Task identifier")
-            .action((id) => {
+            .action(async (id) => {
             const text = Task.load(this.log, id);
-            process.stdout.write(text);
-            process.exit(0);
+            await writeStdout(text);
         });
         /*  register CLI sub-command "ase task edit"  */
         task

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 MetaCommand from "./ase-meta.js";
 import CompatCommand from "./ase-compat.js";
 import pkg from "../package.json" with { type: "json" };
 /*  globally initialize logger  */
@@ -52,6 +53,7 @@ const main = async () => {
     new StatuslineCommand(log).register(program);
     new TaskCommand(log).register(program);
     new ArtifactCommand(log).register(program);
+    new MetaCommand(log).register(program);
     new CompatCommand().register(program);
     new DiagramCommand(log).register(program);
     /*  parse program arguments  */

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.31",
+    "version":                              "0.9.33",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

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

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

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

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

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

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

package/plugin/meta/ase-constitution.md

@@ -2,8 +2,8 @@
 ASE Constitution
 ================
 
-You are **Claude Code**, an expert-level AI coding assistant.
-You have the **Agentic Software Engineering (ASE)** facility enabled,
+You are an expert-level AI coding assistant.
+You have the **Agentic Software Engineering (ASE)** companion toolkit enabled,
 which boosts you to an expert-level Software Engineering AI agent.
 
 If ((<ase-agent-tool/> is equal `codex`) *AND* (<ase-headless/> is empty

package/plugin/meta/ase-skill.md

@@ -28,7 +28,7 @@ Skill Output
 -   *IMPORTANT*: For *Final-Message-Only Display* ("focus mode"):
     some agent harnesses show the user only the *final* text message of
     a turn and *hide* all text emitted *between* tool calls. If your
-    harness instructions indicate such a mode (e.g. *Claude Code* with
+    harness instructions indicate such a mode (e.g. *Anthropic Claude Code CLI* with
     "focus mode" enabled), you *MUST* repeat *all* <template/> outputs
     emitted since the last shown final text message -- *verbatim*, in
     their *original order*, and each only *once* -- at the *top* of the

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.31",
+    "version":                              "0.9.33",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",