@rse/ase 0.9.47 → 0.9.48

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,7 +14,8 @@ 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"]
@@ -93,20 +94,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 +168,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,12 +180,12 @@ 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({

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-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()),
@@ -273,7 +267,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 =
@@ -371,7 +371,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 +458,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 +543,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));
+            });
     }
 }

package/dst/ase-kv.js

@@ -30,10 +30,10 @@ export class KV {
         KV.validateKey(key);
         return KV.store.has(key);
     }
-    /*  get a value by key; returns undefined if no value is stored  */
+    /*  get a deep copy of a value by key; returns undefined if no value is stored  */
     static get(key) {
         KV.validateKey(key);
-        return KV.store.get(key);
+        return structuredClone(KV.store.get(key));
     }
     /*  set a value under the given key; overwrites any existing value  */
     static set(key, val) {
@@ -103,6 +103,17 @@ export class KV {
             throw new Error(`invalid command "${String(c.command)}"`);
     }
 }
+/*  extract the message of a caught error  */
+const errorMessage = (err) => err instanceof Error ? err.message : String(err);
+/*  execute a single key/value command and render it as an MCP tool result  */
+const mcpToolExec = (c) => {
+    try {
+        return { content: [{ type: "text", text: KV.execute(c) }] };
+    }
+    catch (err) {
+        return { isError: true, content: [{ type: "text", text: `ERROR: ${errorMessage(err)}` }] };
+    }
+};
 /*  MCP registration entry point for in-memory key/value tools  */
 export class KVMCP {
     register(mcp) {
@@ -115,16 +126,7 @@ export class KVMCP {
                 key: z.string()
                     .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
-        }, async (args) => {
-            try {
-                const text = KV.execute({ command: "get", key: args.key });
-                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}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "get", key: args.key }));
         /*  key/value set  */
         mcp.registerTool("ase_kv_set", {
             title: "ASE key/value set",
@@ -137,16 +139,7 @@ export class KVMCP {
                 val: z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.unknown()), z.record(z.string(), z.unknown())])
                     .describe("arbitrary JSON-compatible value to store under `key`")
             }
-        }, async (args) => {
-            try {
-                const text = KV.execute({ command: "set", key: args.key, val: args.val });
-                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}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "set", key: args.key, val: args.val }));
         /*  key/value clear  */
         mcp.registerTool("ase_kv_clear", {
             title: "ASE key/value clear",
@@ -158,16 +151,7 @@ export class KVMCP {
                 prefix: z.string().optional()
                     .describe("if given, only remove keys starting with this prefix (otherwise remove all keys)")
             }
-        }, async (args) => {
-            try {
-                const text = KV.execute({ command: "clear", prefix: args.prefix });
-                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}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "clear", prefix: args.prefix }));
         /*  key/value delete  */
         mcp.registerTool("ase_kv_delete", {
             title: "ASE key/value delete",
@@ -177,16 +161,7 @@ export class KVMCP {
                 key: z.string()
                     .describe("key identifier (non-empty, no whitespace-only, no control characters, up to 1024 characters)")
             }
-        }, async (args) => {
-            try {
-                const text = KV.execute({ command: "delete", key: args.key });
-                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}` }] };
-            }
-        });
+        }, async (args) => mcpToolExec({ command: "delete", key: args.key }));
         /*  key/value batch  */
         mcp.registerTool("ase_kv_batch", {
             title: "ASE key/value batch",
@@ -226,7 +201,7 @@ export class KVMCP {
                     results.push(KV.execute(c));
                 }
                 catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
+                    const message = errorMessage(err);
                     if (tx) {
                         if (snapshot !== null)
                             KV.restore(snapshot);

package/dst/ase-mcp.js

@@ -23,7 +23,7 @@ export default class MCPCommand {
         let ctx = this.loadContext();
         /*  fast path: already running  */
         if (ctx.port !== null) {
-            const match = await probe(ctx.port, ctx.projectId);
+            const match = await probe(ctx.port, ctx.projectId).catch(() => null);
             if (match === true)
                 return { projectId: ctx.projectId, port: ctx.port };
         }

package/dst/ase-meta.js

@@ -6,7 +6,7 @@
 import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { writeStdout } from "./ase-stdout.js";
+import { writeStdout } from "./ase-stdio.js";
 /*  reusable functionality: resolve and read plugin "meta/" files  */
 export class Meta {
     /*  determine the plugin "meta/" directory; the build process copies

package/dst/ase-service.js

@@ -494,7 +494,7 @@ export default class ServiceCommand {
             process.stdout.write("service: not running (no port configured)\n");
             return 1;
         }
-        const match = await probe(ctx.port, ctx.projectId);
+        const match = await probe(ctx.port, ctx.projectId).catch(() => null);
         if (match === true) {
             const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, this.commandRequest("status", 2000));
             const d = r._data;
@@ -513,13 +513,13 @@ export default class ServiceCommand {
     /*  send command: POST /command with the arbitrary cmd token  */
     async doSend(cmd) {
         let ctx = this.loadContext();
-        if (ctx.port === null || await probe(ctx.port, ctx.projectId) !== true) {
+        if (ctx.port === null || await probe(ctx.port, ctx.projectId).catch(() => null) !== true) {
             /*  auto-start the service once, then re-check  */
             await this.doStart();
             ctx = this.loadContext();
             if (ctx.port === null)
                 throw new Error("service not running (no port configured after auto-start)");
-            if (await probe(ctx.port, ctx.projectId) !== true)
+            if (await probe(ctx.port, ctx.projectId).catch(() => null) !== true)
                 throw new Error(`service not responding on port ${ctx.port} after auto-start`);
         }
         const r = await ofetch.raw(`http://${HOST}:${ctx.port}/command`, { ...this.commandRequest(cmd, 5000), responseType: "text" });
@@ -536,7 +536,7 @@ export default class ServiceCommand {
             this.log.write("info", "service: not running (no port configured)");
             return 0;
         }
-        const match = await probe(ctx.port, ctx.projectId);
+        const match = await probe(ctx.port, ctx.projectId).catch(() => null);
         if (match === false) {
             this.log.write("info", `service: not running (port ${ctx.port} in use by foreign service)`);
             return 1;

package/dst/ase-setup.js

@@ -356,29 +356,13 @@ export default class SetupCommand {
                 args.push(name, transport.url);
             }
         }
-        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
-                positional argument  */
-            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 {
-                args.push("--transport", "http");
-                for (const [key, val] of Object.entries(transport.headers ?? {}))
-                    args.push("--header", `${key}: ${val}`);
-                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)  */
+            /*  the GitHub Copilot CLI and OpenAI Codex CLI both take the
+                server name as a positional argument and imply the stdio
+                transport when the command is provided after "--"; for "http"
+                servers the GitHub Copilot CLI needs an explicit
+                "--transport" flag and takes the URL positionally, while the
+                OpenAI Codex CLI takes it via the "--url" option  */
             if (transport.type === "stdio") {
                 args.push(name);
                 for (const [key, val] of Object.entries(env))
@@ -386,9 +370,14 @@ export default class SetupCommand {
                 args.push("--", ...transport.command);
             }
             else {
+                if (tool === "copilot")
+                    args.push("--transport", "http");
                 for (const [key, val] of Object.entries(transport.headers ?? {}))
                     args.push("--header", `${key}: ${val}`);
-                args.push(name, "--url", transport.url);
+                if (tool === "copilot")
+                    args.push(name, transport.url);
+                else
+                    args.push(name, "--url", transport.url);
             }
         }
         await this.run(toolSpecs[tool].cli, args);
@@ -657,24 +646,18 @@ export default class SetupCommand {
         AST, reproducing the exact whitespace tokens json-asty emits for a
         canonically 4-space-indented settings.json  */
     statuslineBuildMember(root, command) {
-        const strMember = (key, val, epilog) => {
-            const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
-            const v = root.create("string").set({ body: JSON.stringify(val), value: val });
-            const m = root.create("member");
-            if (epilog !== undefined)
-                m.set({ epilog });
-            return m.add(k, v);
-        };
-        const numMember = (key, val, epilog) => {
+        const member = (key, val, epilog) => {
+            const type = typeof val === "number" ? "number" : "string";
+            const body = typeof val === "number" ? String(val) : JSON.stringify(val);
             const k = root.create("string").set({ body: JSON.stringify(key), value: key, epilog: ": " });
-            const v = root.create("number").set({ body: String(val), value: val });
+            const v = root.create(type).set({ body, value: val });
             const m = root.create("member");
             if (epilog !== undefined)
                 m.set({ epilog });
             return m.add(k, v);
         };
         const obj = root.create("object").set({ prolog: "{\n        ", epilog: "\n    }\n" });
-        obj.add(strMember("type", "command", ",\n        "), strMember("command", command, ",\n        "), numMember("padding", 0));
+        obj.add(member("type", "command", ",\n        "), member("command", command, ",\n        "), member("padding", 0));
         const key = root.create("string").set({
             body: JSON.stringify("statusLine"),
             value: "statusLine",

package/dst/ase-skills.js

@@ -54,7 +54,7 @@ export class Skills {
     }
     /*  fetch GitHub stars given a repository URL (or empty string)  */
     static async fetchStars(repository) {
-        const m = /^.+?\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:[/#?].*)?$/.exec(repository);
+        const m = /^(?:.*?:\/\/)?(?:[^@/]*@)?github\.com[:/]([^/]+\/[^/#?]+?)(?:\.git)?(?:[/#?].*)?$/.exec(repository);
         if (m === null)
             return "N.A.";
         try {

package/dst/ase-statusline.js

@@ -11,7 +11,7 @@ import { InvalidArgumentError } from "commander";
 import { execaSync } from "execa";
 import { Chalk } from "chalk";
 import { Config, configSchema, parseScope } from "./ase-config.js";
-import { writeStdout } from "./ase-stdout.js";
+import { readStdin, writeStdout } from "./ase-stdio.js";
 import pkg from "../package.json" with { type: "json" };
 /*  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
@@ -28,13 +28,6 @@ const parseInteger = (name) => (value) => {
         throw new InvalidArgumentError(`${name} must be a non-negative integer`);
     return n;
 };
-/*  read stdin into a single string  */
-const readStdin = async () => {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        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 Anthropic Claude Code CLI)  */
 const detectTermWidth = () => {
     let width = 0;
@@ -218,8 +211,7 @@ export default class StatuslineCommand {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                this.log.write("error", `statusline: invalid JSON on stdin: ${message}`);
-                process.exit(1);
+                throw new Error(`statusline: invalid JSON on stdin: ${message}`);
             }
             /*  normalize Copilot CLI's top-level "cwd" into the
                 "workspace.current_dir" structure shared with Anthropic Claude Code CLI  */
@@ -340,10 +332,18 @@ export default class StatuslineCommand {
                     emit(`${prefix("◔", "context")}${bar} ${pct}%`);
                 },
                 C: () => {
-                    const pct = data.context_window?.used_percentage ?? 0;
-                    const tokensCur = (data.context_window?.total_input_tokens ?? 0) +
-                        (data.context_window?.total_output_tokens ?? 0);
-                    const tokensLim = pct > 0 && tokensCur > 0 ? Math.round(tokensCur * 100 / pct) : 0;
+                    /*  probe the live-context fields first and fall back to the
+                        cumulative ones, so each harness contributes its own view:
+                        GitHub Copilot CLI reports the live window separately (its
+                        "total_*" are session sums), whereas Anthropic Claude Code CLI
+                        folds it into "total_input_tokens". Output tokens stay out --
+                        "used_percentage" is input-side only.  */
+                    const cw = data.context_window;
+                    const pct = cw?.used_percentage ?? 0;
+                    const tokensCur = cw?.current_context_tokens ??
+                        cw?.last_call_input_tokens ?? cw?.total_input_tokens ?? 0;
+                    const tokensLim = cw?.displayed_context_limit ?? cw?.context_window_size ??
+                        (pct > 0 && tokensCur > 0 ? Math.round(tokensCur * 100 / pct) : 0);
                     if (tokensLim > 0)
                         emit(`${prefix("◆", "tokens")}${c.bold(formatTokens(tokensCur) + "/" + formatTokens(tokensLim))}`);
                 },

package/dst/ase-stdio.js

@@ -0,0 +1,25 @@
+/*
+**  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 getStdin from "get-stdin";
+/*  read the entire stdin payload as a UTF-8 string, treating an
+    interactive terminal as empty input so callers never block on a
+    user which is not going to type anything  */
+export const readStdin = () => {
+    return getStdin();
+};
+/*  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

@@ -13,7 +13,7 @@ import { z } from "zod";
 import { LRUCache } from "lru-cache";
 import { Config, configSchema, parseScope } from "./ase-config.js";
 import { Markdown } from "./ase-markdown.js";
-import { writeStdout } from "./ase-stdout.js";
+import { readStdin, writeStdout } from "./ase-stdio.js";
 /*  reusable functionality: persisted task plans under
     <project>/<basedir>/TASK-<id>.md (driven by the
     "project.artifact.task.{basedir,files}" configuration)  */
@@ -56,11 +56,18 @@ export class Task {
         Task.projectRootCache.set(cwd, root);
         return root;
     }
+    /*  cached task storage specification (TTL-bounded, mirroring the project
+        root cache, as each read parses the whole layered YAML config chain)  */
+    static specCache = new LRUCache({ max: 4, ttl: 2 * 1000 });
     /*  read the configured "basedir" anchor and "files" miniglob spec for
         task storage; "basedir" is project-root-relative (POSIX, defaults
         to ".ase/task") and "files" constrains the task filenames
         (defaults to "*.md")  */
     static spec(log) {
+        const root = Task.projectRoot();
+        const cached = Task.specCache.get(root);
+        if (cached !== undefined)
+            return cached;
         const cfg = new Config("config", configSchema, log);
         cfg.read();
         const read = (key) => {
@@ -74,7 +81,9 @@ export class Task {
         if (basedir.split("/").includes(".."))
             throw new Error(`task: configured "basedir" "${basedir}" must not escape the project root`);
         const files = read("project.artifact.task.files") || "*.md";
-        return { basedir, files };
+        const result = { basedir, files };
+        Task.specCache.set(root, result);
+        return result;
     }
     /*  resolve the on-disk base directory for task storage  */
     static baseDir(log) {
@@ -245,15 +254,6 @@ export class Task {
         });
     }
 }
-/*  read all of stdin as a UTF-8 string  */
-const readStdin = () => {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        process.stdin.on("data", (chunk) => chunks.push(chunk));
-        process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-        process.stdin.on("error", (err) => reject(err));
-    });
-};
 /*  CLI command "ase task"  */
 export default class TaskCommand {
     log;

package/dst/ase.js

@@ -60,7 +60,7 @@ const main = async () => {
     await program.parseAsync(process.argv);
     /*  gracefully terminate  */
     await log.close();
-    process.exit(0);
+    process.exit(process.exitCode ?? 0);
 };
 main().catch(async (err) => {
     if (err instanceof CommanderError) {

package/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.47",
+    "version":                              "0.9.48",
     "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.47",
+    "version":     "0.9.48",
     "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.47",
+    "version":     "0.9.48",
     "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.47",
+    "version":     "0.9.48",
     "description": "Agentic Software Engineering (ASE)",
     "keywords":    [ "agentic", "software", "engineering" ],
     "homepage":    "https://ase.tools",

package/plugin/package.json

@@ -6,7 +6,7 @@
     "homepage":                             "https://ase.tools",
     "repository":                           { "url": "git+https://github.com/rse/ase.git", "type": "git" },
     "bugs":                                 { "url": "https://github.com/rse/ase/issues" },
-    "version":                              "0.9.47",
+    "version":                              "0.9.48",
     "license":                              "Apache-2.0",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",

package/plugin/skills/ase-help-intent/SKILL.md

@@ -102,16 +102,11 @@ catalog you match <intent/> against:
         <template>
         <ase-tpl-head title="SKILL COMMAND PROPOSAL"/>
 
-        ●   **INTENT**:
-        ○   <intent/>
-
-        ●   **COMMAND**:
-        ⌘   `<command/>`
-
-        ●   **RATIONALE**:
-        ○   <rationale/>
+        ❯ `<command/>`
 
         <ase-tpl-foot title="SKILL COMMAND PROPOSAL"/>
+
+        **RATIONALE**: <rationale/>
         </template>
 
     4.  *Dispatch Command*: