@rse/ase 0.9.47 → 0.9.49

package/dst/ase-artifact.js

@@ -10,7 +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";
+import { writeStdout } from "./ase-stdio.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"];
@@ -141,6 +141,8 @@ export class Artifact {
         const basedir = Artifact.configString(cfg, `project.artifact.${kind}.basedir`)
             .replace(/\\/g, "/").replace(/^\/+|\/+$/g, "")
             .replace(/^\.$/, "");
+        if (basedir.split("/").includes(".."))
+            throw new Error(`artifact: configured "basedir" "${basedir}" must not escape the project root`);
         const files = Artifact.configString(cfg, `project.artifact.${kind}.files`);
         return { basedir, files };
     }

package/dst/ase-compat.js

@@ -3,7 +3,7 @@
 **  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
 */
-import { writeStdout } from "./ase-stdout.js";
+import { writeStdout } from "./ase-stdio.js";
 /*  the canonical expected values for every ase-meta-compat probe,
     keyed by "<category>/<probe-name>" as used in the skill  */
 const EXPECTED = {

package/dst/ase-config.js

@@ -14,14 +14,16 @@ import Table from "cli-table3";
 import writeFileAtomic from "write-file-atomic";
 import lockfile from "proper-lockfile";
 import { z } from "zod";
-import { writeStdout } from "./ase-stdout.js";
+import { LRUCache } from "lru-cache";
+import { writeStdout } from "./ase-stdio.js";
 /*  classification taxonomy  */
 export const projectClassification = {
     boxing: ["white", "grey", "black"]
 };
 /*  agent classification taxonomy  */
 export const agentClassification = {
-    persona: ["writer", "engineer", "journalist", "telegrapher", "caveman"]
+    persona: ["writer", "engineer", "journalist", "telegrapher", "caveman"],
+    guidance: ["none", "minimal", "normal", "verbose"]
 };
 /*  classification presets  */
 export const projectClassificationPresets = {
@@ -40,6 +42,7 @@ export const projectClassificationPresets = {
     default: {
         "agent.task": "default",
         "agent.persona": "engineer",
+        "agent.guidance": "normal",
         "project.id": "example",
         "project.name": "Example Project",
         "project.boxing": "white",
@@ -93,20 +96,33 @@ const parseScopeTerm = (value) => {
     else if (value === "project")
         return { kind: "project" };
     const m = /^(session|task):([A-Za-z0-9._-]+)$/.exec(value);
-    if (m !== null)
+    if (m !== null) {
+        if (m[2] === "." || m[2] === "..")
+            throw new Error(`invalid --scope term "${value}": id must not be "." or ".."`);
         return { kind: m[1], id: m[2] };
+    }
     throw new Error(`invalid --scope term "${value}" ` +
         "(expected: \"user\", \"project\", \"task:<id>\", or \"session:<id>\")");
 };
-/*  determine the Git top-level directory, if inside a Git repository  */
+/*  determine the Git top-level directory, if inside a Git repository;
+    cached per working directory ("" ≡ not inside a Git working tree), as
+    each determination spawns a Git subprocess and the Git context can
+    change over the lifetime of the long-running ASE service  */
+const gitToplevelCache = new LRUCache({ max: 4, ttl: 2 * 1000 });
 const gitToplevel = () => {
+    const cwd = process.cwd();
+    const cached = gitToplevelCache.get(cwd);
+    if (cached !== undefined)
+        return cached === "" ? null : cached;
+    let top = "";
     try {
-        const result = execaSync("git", ["rev-parse", "--show-toplevel"], { stderr: "ignore" });
-        return result.stdout.trim() || null;
+        top = execaSync("git", ["rev-parse", "--show-toplevel"], { stderr: "ignore" }).stdout.trim();
     }
     catch {
-        return null;
+        /*  not inside a Git working tree  */
     }
+    gitToplevelCache.set(cwd, top);
+    return top === "" ? null : top;
 };
 /*  detect whether a project context exists, i.e. either we are inside
     a Git working tree or a ".ase" directory is present at or above cwd  */
@@ -154,6 +170,11 @@ export const parseScope = (value) => {
     terms.unshift({ kind: "default" });
     return terms;
 };
+/*  schema for a single artifact kind's "basedir"/"files" specification  */
+const artifactSchema = v.optional(v.strictObject({
+    basedir: v.optional(v.string()),
+    files: v.optional(v.string())
+}));
 /*  schema for ".ase/config.yaml"  */
 export const configSchema = v.nullish(v.strictObject({
     project: v.optional(v.strictObject({
@@ -161,16 +182,17 @@ export const configSchema = v.nullish(v.strictObject({
         name: v.optional(v.pipe(v.string(), v.minLength(1))),
         boxing: v.optional(v.picklist(projectClassification.boxing)),
         artifact: v.optional(v.strictObject({
-            spec: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) })),
-            arch: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) })),
-            code: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) })),
-            docs: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) })),
-            infr: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) })),
-            task: v.optional(v.strictObject({ basedir: v.optional(v.string()), files: v.optional(v.string()) }))
+            spec: artifactSchema,
+            arch: artifactSchema,
+            code: artifactSchema,
+            docs: artifactSchema,
+            infr: artifactSchema,
+            task: artifactSchema
         }))
     })),
     agent: v.optional(v.strictObject({
         persona: v.optional(v.picklist(agentClassification.persona)),
+        guidance: v.optional(v.picklist(agentClassification.guidance)),
         task: v.optional(v.pipe(v.string(), v.minLength(1))),
         skill: v.optional(v.pipe(v.string(), v.minLength(1)))
     }))
@@ -749,5 +771,46 @@ export class ConfigMCP {
                 return mcpToolError(err);
             }
         });
+        /*  config list  */
+        mcp.registerTool("ase_config_list", {
+            title: "ASE config list",
+            description: "List all effective configuration entries of the layered configuration, " +
+                "cascading through the default/user/project/task/session chain up to and " +
+                "including the requested `scope`. Returns an `entries` array (in lexicographic " +
+                "`key` order) where each item has the dotted `key`, its effective `value`, and " +
+                "the `scope` label (\"default\", \"user\", \"project\", \"task:<id>\", or " +
+                "\"session:<id>\") that supplied it. For overlapping keys only the value of the " +
+                "strongest scope is reported.",
+            inputSchema: {
+                scope: z.string()
+                    .describe("scope chain (e.g. \"session:<id>\", \"task:<id>\", \"project\", \"user\")")
+            },
+            outputSchema: {
+                entries: z.array(z.object({
+                    key: z.string().describe("dotted configuration key"),
+                    value: z.string().describe("effective configuration value"),
+                    scope: z.string().describe("scope label which supplied the value")
+                })).describe("all effective configuration entries in lexicographic key order")
+            }
+        }, async (args) => {
+            try {
+                const scope = parseScope(args.scope);
+                const cfg = new Config("config", configSchema, this.log, scope);
+                cfg.read();
+                const entries = cfg.entries().map((e) => ({
+                    key: e.key,
+                    value: String(isScalar(e.value) ? e.value.value : e.value),
+                    scope: Config.scopeLabel(e.scope)
+                }));
+                const result = { entries };
+                return {
+                    structuredContent: result,
+                    content: [{ type: "text", text: JSON.stringify(result) }]
+                };
+            }
+            catch (err) {
+                return mcpToolError(err);
+            }
+        });
     }
 }

package/dst/ase-diagram.js

@@ -7,7 +7,7 @@ import fs from "node:fs";
 import { InvalidArgumentError } from "commander";
 import { renderMermaidASCII, renderMermaidSVG } from "beautiful-mermaid";
 import { z } from "zod";
-import getStdin from "get-stdin";
+import { readStdin } from "./ase-stdio.js";
 /*  custom argument parser for Commander: non-negative integer  */
 const parseInteger = (name) => (value) => {
     const n = Number.parseInt(value, 10);
@@ -150,6 +150,8 @@ export class Diagram {
             clipping below are meaningful only for ASCII art)  */
         if (opts.format === "svg")
             return renderMermaidSVG(src);
+        /*  determine theme colors (gray shades once colors are enabled)  */
+        const colored = opts.colorMode !== "none";
         /*  create diagram rendering  */
         let out = renderMermaidASCII(src, {
             useAscii: opts.ascii,
@@ -157,20 +159,13 @@ export class Diagram {
             paddingY: opts.nodeMarginY,
             boxBorderPadding: opts.nodePadding,
             colorMode: opts.colorMode,
-            theme: opts.colorMode !== "none" ? {
+            theme: {
                 fg: "#000000",
-                border: "#a0a0a0",
-                junction: "#a0a0a0",
-                arrow: "#404040",
-                line: "#707070",
-                corner: "#707070"
-            } : {
-                fg: "#000000",
-                border: "#000000",
-                junction: "#000000",
-                arrow: "#000000",
-                line: "#000000",
-                corner: "#000000"
+                border: colored ? "#a0a0a0" : "#000000",
+                junction: colored ? "#a0a0a0" : "#000000",
+                arrow: colored ? "#404040" : "#000000",
+                line: colored ? "#707070" : "#000000",
+                corner: colored ? "#707070" : "#000000"
             }
         });
         /*  optionally clip diagram rendering  */
@@ -248,7 +243,7 @@ export default class DiagramCommand {
                 }
             }
             else
-                src = await getStdin();
+                src = await readStdin();
             if (src.trim() === "") {
                 this.log.write("error", "diagram: empty Mermaid diagram specification");
                 process.exit(1);

package/dst/ase-getopt.js

@@ -6,6 +6,70 @@
 import { z } from "zod";
 import { Command, Option } from "commander";
 import { parse as shParse, quote as shQuote } from "shell-quote";
+/*  tokenize a raw input string into [start,end) token ranges, preserving
+    the quoting so the original text can later be sliced verbatim  */
+const tokenizeRanges = (input) => {
+    const ranges = [];
+    let i = 0;
+    while (i < input.length) {
+        while (i < input.length && /\s/.test(input[i]))
+            i++;
+        if (i >= input.length)
+            break;
+        const start = i;
+        while (i < input.length && !/\s/.test(input[i])) {
+            const ch = input[i];
+            if (ch === "\"" || ch === "'") {
+                const quote = ch;
+                i++;
+                while (i < input.length && input[i] !== quote) {
+                    if (input[i] === "\\" && i + 1 < input.length)
+                        i++;
+                    i++;
+                }
+                if (i < input.length)
+                    i++;
+            }
+            else
+                i++;
+        }
+        ranges.push({ start, end: i });
+    }
+    return ranges;
+};
+/*  strip surrounding quotes/escapes from a raw token range so it can be
+    compared against an option flag spelling  */
+const unquote = (s) => {
+    let out = "";
+    let j = 0;
+    while (j < s.length) {
+        const ch = s[j];
+        if (ch === "\"" || ch === "'") {
+            const quote = ch;
+            j++;
+            while (j < s.length && s[j] !== quote) {
+                if (s[j] === "\\" && j + 1 < s.length) {
+                    out += s[j + 1];
+                    j += 2;
+                }
+                else {
+                    out += s[j];
+                    j++;
+                }
+            }
+            j++;
+        }
+        else if (ch === "\\" && j + 1 < s.length) {
+            out += s[j + 1];
+            j += 2;
+        }
+        else {
+            out += ch;
+            j++;
+        }
+    }
+    return out;
+};
 /*  MCP registration entry point for the option-parser tool  */
 export class GetoptMCP {
     register(mcp) {
@@ -117,65 +181,7 @@ export class GetoptMCP {
                 let argsVerbatim = "";
                 if (argsRaw !== null) {
                     /*  tokenize raw input into [start,end) ranges, preserving quotes  */
-                    const ranges = [];
-                    let i = 0;
-                    while (i < argsRaw.length) {
-                        while (i < argsRaw.length && /\s/.test(argsRaw[i]))
-                            i++;
-                        if (i >= argsRaw.length)
-                            break;
-                        const start = i;
-                        while (i < argsRaw.length && !/\s/.test(argsRaw[i])) {
-                            const ch = argsRaw[i];
-                            if (ch === "\"" || ch === "'") {
-                                const quote = ch;
-                                i++;
-                                while (i < argsRaw.length && argsRaw[i] !== quote) {
-                                    if (argsRaw[i] === "\\" && i + 1 < argsRaw.length)
-                                        i++;
-                                    i++;
-                                }
-                                if (i < argsRaw.length)
-                                    i++;
-                            }
-                            else
-                                i++;
-                        }
-                        ranges.push({ start, end: i });
-                    }
-                    /*  helper function: strip surrounding quotes/escapes from a raw
-                        range so it can be compared against an option flag spelling  */
-                    const unquote = (s) => {
-                        let out = "";
-                        let j = 0;
-                        while (j < s.length) {
-                            const ch = s[j];
-                            if (ch === "\"" || ch === "'") {
-                                const quote = ch;
-                                j++;
-                                while (j < s.length && s[j] !== quote) {
-                                    if (s[j] === "\\" && j + 1 < s.length) {
-                                        out += s[j + 1];
-                                        j += 2;
-                                    }
-                                    else {
-                                        out += s[j];
-                                        j++;
-                                    }
-                                }
-                                j++;
-                            }
-                            else if (ch === "\\" && j + 1 < s.length) {
-                                out += s[j + 1];
-                                j += 2;
-                            }
-                            else {
-                                out += ch;
-                                j++;
-                            }
-                        }
-                        return out;
-                    };
+                    const ranges = tokenizeRanges(argsRaw);
                     /*  walk the raw ranges, consuming leading option tokens (and any
                         separate value tokens they take) until the first positional
                         is reached, then slice the original input from there -- this
@@ -202,7 +208,7 @@ export class GetoptMCP {
                         argsVerbatim = argsRaw.slice(ranges[idx].start);
                 }
                 else
-                    argsVerbatim = cmd.args.join(" ");
+                    argsVerbatim = shQuote(cmd.args);
                 /*  build markdown info rendering of parsed options  */
                 const opts = cmd.opts();
                 const info = Object.entries(opts)

package/dst/ase-guidance.js

@@ -0,0 +1,89 @@
+/*
+**  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 { isScalar } from "yaml";
+import { z } from "zod";
+import { Config, configSchema, parseScope, agentClassification } from "./ase-config.js";
+/*  reusable functionality: ASE agent guidance level get/set  */
+export class Guidance {
+    /*  allowed guidance level values  */
+    static levels = agentClassification.guidance;
+    /*  get the effective guidance level for an optional session;
+        returns the default "normal" if nothing is configured  */
+    static get(log, session) {
+        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
+        const cfg = new Config("config", configSchema, log, scope);
+        cfg.read();
+        const val = cfg.get("agent.guidance");
+        if (val === undefined)
+            return "normal";
+        const level = String(isScalar(val) ? val.value : val);
+        return Guidance.levels.find((l) => l === level) ?? "normal";
+    }
+    /*  set the guidance level on the strongest scope of an optional session  */
+    static set(log, level, session) {
+        const scope = parseScope(session !== undefined ? `session:${session}` : undefined);
+        const cfg = new Config("config", configSchema, log, scope);
+        cfg.lock(() => {
+            cfg.read();
+            cfg.set("agent.guidance", level);
+            cfg.write();
+        });
+    }
+}
+/*  MCP registration entry point for guidance tools  */
+export default class GuidanceMCP {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    register(mcp) {
+        mcp.registerTool("ase_guidance", {
+            title: "ASE guidance level get/set",
+            description: "Get or set the active ASE agent guidance `level`. " +
+                "If `level` is provided, it sets the guidance level, " +
+                "otherwise it returns the current guidance `level`. " +
+                "If `session` is provided, the operation is scoped to that session, " +
+                "otherwise it operates on the strongest/closest scope (user/project cascade). " +
+                "The guidance level controls the amount of unsolicited help hints -- " +
+                "pointers to the available ASE skills, their options, and the recommended " +
+                "next operations -- the agent emits. " +
+                "Allowed levels: \"none\" (no help hints at all), " +
+                "\"minimal\" (the single most essential help hint only), " +
+                "\"normal\" (the essential help hints only), " +
+                "\"verbose\" (all available help hints).",
+            inputSchema: {
+                level: z.enum(Guidance.levels).optional()
+                    .describe("guidance level to set; if omitted, the current guidance level is returned"),
+                session: z.string().regex(/^[A-Za-z0-9._-]+$/).optional()
+                    .describe("session identifier (allowed characters: A-Z, a-z, 0-9, '.', '_', '-'); " +
+                    "if omitted, the operation is not scoped to a specific session")
+            }
+        }, async (args) => {
+            try {
+                if (args.level !== undefined) {
+                    Guidance.set(this.log, args.level, args.session);
+                    const where = args.session !== undefined ?
+                        ` for session "${args.session}"` : "";
+                    const msg = `OK: set agent.guidance to "${args.level}"${where}`;
+                    return {
+                        content: [{ type: "text", text: msg }]
+                    };
+                }
+                const text = Guidance.get(this.log, args.session);
+                return {
+                    content: [{ type: "text", text }]
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `ERROR: ${message}` }]
+                };
+            }
+        });
+    }
+}

package/dst/ase-hook.js

@@ -8,11 +8,10 @@ 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";
-import { writeStdout } from "./ase-stdout.js";
+import { readStdin, writeStdout } from "./ase-stdio.js";
 const addonMcpServers = [
     "chat-alibaba-qwen",
     "chat-deepseek",
@@ -86,14 +85,9 @@ 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();
+        await readStdin().catch(() => "");
     }
     /*  best-effort JSON parse with valibot schema validation: returns
         an empty object on blank input, malformed JSON, or schema
@@ -211,7 +205,7 @@ export default class HookCommand {
         const versionHint = versionHints.length > 0 ? "(" + versionHints.join(", ") + ")" : "";
         /*  read session information (Anthropic Claude Code CLI uses snake_case fields,
             GitHub Copilot CLI uses camelCase fields)  */
-        const stdin = await this.readStdin();
+        const stdin = await readStdin().catch(() => "");
         const input = this.parseJSON(stdin, v.object({
             session_id: v.optional(v.string()),
             sessionId: v.optional(v.string()),
@@ -255,8 +249,9 @@ export default class HookCommand {
             const val = cfg.get(key);
             return typeof val === "string" ? val : (process.env[envVar] ?? dflt);
         };
-        /*  determine agent persona style and project boxing transparency  */
+        /*  determine agent persona style, agent guidance level, and project boxing transparency  */
         const persona = setting("agent.persona", "ASE_PERSONA_STYLE", "engineer");
+        const guidance = setting("agent.guidance", "ASE_GUIDANCE_LEVEL", "normal");
         const boxing = setting("project.boxing", "ASE_PROJECT_BOXING", "white");
         /*  determine headless mode  */
         const headless = (process.env.ASE_HEADLESS ?? "false") === "true" ? "true" : "false";
@@ -273,7 +268,13 @@ export default class HookCommand {
                 `export ASE_SESSION_ID=${quote([sessionId])}\n` +
                 `export ASE_HEADLESS=${quote([headless])}\n` +
                 `export ASE_AGENT_TOOL=${quote([tool])}\n`;
-            fs.appendFileSync(envFile, script, "utf8");
+            try {
+                fs.appendFileSync(envFile, script, "utf8");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.write("warning", `hook: failed to write environment file: ${message}`);
+            }
         }
         /*  prepend ASE information to constitution markdown  */
         md =
@@ -281,6 +282,7 @@ export default class HookCommand {
                 `<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-guidance-level>${guidance}</ase-guidance-level>\n` +
                 `<ase-user-id>${userId}</ase-user-id>\n` +
                 `<ase-project-id>${projectId}</ase-project-id>\n` +
                 `<ase-project-boxing>${boxing}</ase-project-boxing>\n` +
@@ -295,11 +297,18 @@ export default class HookCommand {
             agent harness, independent of any model decision, so it is
             guaranteed to appear once in every non-headless session;
             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, "") : ""}` +
+            "systemMessage" field for this -- GitHub Copilot CLI has no equivalent);
+            the trailing help hint is emitted only if the guidance level asks for it  */
+        const banner = "\n" +
+            `\n⧉ ASE: ⎈ version: ${versionCurrentPlugin}${versionHint !== "" ? " " + versionHint.replaceAll(/\*/g, "") : ""}` +
             `\n⧉ ASE: ※ user: ${userId}, ⚑ project: ${projectId}` +
             `\n⧉ ASE: ◉ task: ${taskId}, ⏻ session: ${sessionId}` +
-            `\n⧉ ASE: ☯ persona: ${persona}, ▢ boxing: ${boxing}`;
+            `\n⧉ ASE: ☯ persona: ${persona}, ▶ guidance: ${guidance}, ▢ boxing: ${boxing}` +
+            (guidance === "normal" || guidance === "verbose" ?
+                "\n" +
+                    "\n⧉ ASE: ▷ hint: use \"/ase-help-intent <intent-description>\" for skill command proposal" +
+                    "\n⧉ ASE: ▷ hint: use \"/ase-help-skill [<skill-name>]\" for skill catalog or skill manpage" : "") +
+            "\n";
         /*  inject markdown into session context.
             Anthropic Claude Code CLI and OpenAI Codex CLI expect the context nested in
             "hookSpecificOutput"; GitHub Copilot CLI expects a flat top-level
@@ -314,8 +323,10 @@ export default class HookCommand {
         };
         /*  attach the deterministic banner as a top-level "systemMessage"
             (only for the harnesses that support it and only when not
-            running headless -- mirroring the constitution box condition)  */
-        if ((tool === "claude" || tool === "codex") && headless !== "true")
+            running headless -- complementing the constitution box condition,
+            which covers exactly the remaining harness GitHub Copilot CLI
+            by letting the model emit the banner itself)  */
+        if ((tool === "claude" || tool === "codex") && headless !== "true" && guidance !== "none")
             payload.systemMessage = banner;
         await writeStdout(JSON.stringify(payload));
         return 0;
@@ -371,7 +382,7 @@ export default class HookCommand {
     }
     /*  read session id from stdin JSON payload  */
     async readSessionIdFromStdin() {
-        const stdin = await this.readStdin();
+        const stdin = await readStdin().catch(() => "");
         const input = this.parseJSON(stdin, v.object({
             session_id: v.optional(v.string()),
             sessionId: v.optional(v.string())
@@ -458,7 +469,7 @@ export default class HookCommand {
         loosely-typed input object shared by the tool-approval handlers  */
     async readHookInput(tool) {
         const spec = toolSpecs[tool];
-        const stdin = await this.readStdin();
+        const stdin = await readStdin().catch(() => "");
         const input = this.parseJSON(stdin, v.looseObject({
             session_id: v.optional(v.string()),
             sessionId: v.optional(v.string())
@@ -543,53 +554,22 @@ export default class HookCommand {
             hookCmd.outputHelp();
             process.exit(1);
         });
-        /*  register CLI sub-command "ase hook session-start"  */
-        hookCmd
-            .command("session-start")
-            .description("handle SessionStart hook event")
-            .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
-            .action(async (opts) => {
-            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\", \"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\", \"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\", \"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\", \"copilot\", or \"codex\")", toolDflt)
-            .action(async (opts) => {
-            process.exitCode = await this.doStop(this.parseTool(opts.tool));
-        });
+        /*  register CLI sub-commands "ase hook <event>"  */
+        const subCmds = [
+            { name: "session-start", desc: "handle SessionStart hook event", handler: (tool) => this.doSessionStart(tool) },
+            { name: "session-end", desc: "handle SessionEnd hook event", handler: (tool) => this.doSessionEnd(tool) },
+            { name: "pre-tool-use", desc: "handle tool PreToolUse hook event", handler: (tool) => this.doPreToolUse(tool) },
+            { name: "permission-request", desc: "handle tool PermissionRequest hook event", handler: (tool) => this.doPermissionRequest(tool) },
+            { name: "user-prompt-submit", desc: "handle UserPromptSubmit hook event", handler: (tool) => this.doUserPromptSubmit(tool) },
+            { name: "stop", desc: "handle Stop hook event", handler: (tool) => this.doStop(tool) }
+        ];
+        for (const { name, desc, handler } of subCmds)
+            hookCmd
+                .command(name)
+                .description(desc)
+                .option("-t, --tool <tool>", "target tool (\"claude\", \"copilot\", or \"codex\")", toolDflt)
+                .action(async (opts) => {
+                process.exitCode = await handler(this.parseTool(opts.tool));
+            });
     }
 }