@rse/ase 0.0.19 → 0.0.21

package/dst/ase-claude.js

@@ -0,0 +1,116 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import { execa, execaSync } from "execa";
+import which from "which";
+import { Config, configSchema, parseScope } from "./ase-config.js";
+/*  default statusline arguments (claudeX fallback) used when the
+    "agent.statusline" config variable is empty or unset  */
+const DEFAULT_STATUSLINE_ARGS = "-w 0 -m 2 '<blue>%u</blue> <red>%p</red> <black>%T</black> %s' '%m %e %t' '%P %c'";
+/*  CLI command "ase claude"  */
+export default class ClaudeCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  ensure a tool is available  */
+    async ensureTool(tool) {
+        return which(tool).catch(() => {
+            throw new Error(`mandatory tool "${tool}" not found in $PATH`);
+        });
+    }
+    /*  resolve the statusline command-line arguments from the layered
+        ASE configuration ("agent.statusline"), falling back to the
+        claudeX default if the value is empty or unavailable  */
+    resolveStatuslineArgs() {
+        let args = "";
+        try {
+            const cfg = new Config("config", configSchema, this.log, parseScope("project"));
+            cfg.read("lenient");
+            args = String(cfg.get("agent.statusline") ?? "").trim();
+        }
+        catch (_e) {
+            /*  cascade unavailable; keep fallback  */
+        }
+        if (args === "")
+            args = DEFAULT_STATUSLINE_ARGS;
+        return args;
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("claude")
+            .description("start Claude Code with bootstrapped ASE environment and settings")
+            .passThroughOptions()
+            .allowUnknownOption()
+            .argument("[args...]", "arguments forwarded verbatim to the \"claude\" CLI")
+            .action(async (args) => {
+            /*  ensure Claude Code CLI is available  */
+            await this.ensureTool("claude");
+            /*  bootstrap ASE_TERM_WIDTH from terminal columns  */
+            if (process.env.ASE_TERM_WIDTH === undefined) {
+                let width = 0;
+                if (process.stdout.isTTY) {
+                    const cols = process.stdout.columns;
+                    if (typeof cols === "number" && cols > 0)
+                        width = cols;
+                }
+                process.env.ASE_TERM_WIDTH = `${width}`;
+            }
+            /*  bootstrap ASE_TERM_HEIGHT from terminal rows  */
+            if (process.env.ASE_TERM_HEIGHT === undefined) {
+                let height = 0;
+                if (process.stdout.isTTY) {
+                    const rows = process.stdout.rows;
+                    if (typeof rows === "number" && rows > 0)
+                        height = rows;
+                }
+                process.env.ASE_TERM_HEIGHT = `${height}`;
+            }
+            /*  bootstrap ASE_TERM_COLORS from "tput colors"  */
+            if (process.env.ASE_TERM_COLORS === undefined) {
+                let colorMode = "none";
+                try {
+                    const { stdout } = execaSync("tput", ["colors"], { reject: false });
+                    const n = parseInt(stdout.trim(), 10);
+                    if (!Number.isNaN(n) && n >= 256)
+                        colorMode = "ansi256";
+                    else if (!Number.isNaN(n) && n >= 16)
+                        colorMode = "ansi16";
+                }
+                catch (_e) {
+                    /*  ignore  */
+                }
+                process.env.ASE_TERM_COLORS = colorMode;
+            }
+            /*  resolve statusline arguments (config or claudeX fallback)  */
+            const statuslineArgs = this.resolveStatuslineArgs();
+            /*  build inline Claude Code settings JSON  */
+            const settings = {
+                env: {
+                    DISABLE_TELEMETRY: "1",
+                    DISABLE_AUTOUPDATER: "1",
+                    DISABLE_BUG_COMMAND: "1",
+                    DISABLE_ERROR_REPORTING: "1"
+                },
+                statusLine: {
+                    type: "command",
+                    command: `ase statusline ${statuslineArgs}`,
+                    padding: 0
+                }
+            };
+            const settingsJSON = JSON.stringify(settings);
+            /*  exec Claude Code with the inline settings prepended
+                and any user-supplied arguments forwarded verbatim  */
+            const result = await execa("claude", ["--settings", settingsJSON, ...args], {
+                stdio: "inherit",
+                env: process.env,
+                reject: false,
+                windowsHide: false
+            });
+            process.exit(result.exitCode ?? 0);
+        });
+    }
+}

package/dst/ase-diagram.js

@@ -20,7 +20,7 @@ const parseColorMode = (name) => (value) => {
     return value;
 };
 /*  detect terminal column width  */
-const detectTermWidth = () => {
+export const detectTermWidth = () => {
     let width = 0;
     /*  attempt 1: query environment variable  */
     if (process.env.ASE_TERM_WIDTH !== undefined) {
@@ -37,7 +37,7 @@ const detectTermWidth = () => {
     return width;
 };
 /*  detect terminal row height  */
-const detectTermHeight = () => {
+export const detectTermHeight = () => {
     let height = 0;
     /*  attempt 1: query environment variable  */
     if (process.env.ASE_TERM_HEIGHT !== undefined) {
@@ -112,6 +112,29 @@ const truncateAnsiLine = (line, budget) => {
         out += "\x1b[0m";
     return out;
 };
+/*  measure visible column width of a rendered line, ignoring ANSI escape
+    sequences (CSI ...m); mirrors the visibility model of truncateAnsiLine  */
+const visibleWidth = (line) => {
+    let visible = 0;
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === "\x1b" && line[i + 1] === "[") {
+            let j = i + 2;
+            while (j < line.length && !/[A-Za-z]/.test(line[j]))
+                j++;
+            if (j < line.length) {
+                i = j + 1;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        visible++;
+        i++;
+    }
+    return visible;
+};
 /*  pure rendering helper: turn a Mermaid source string plus options into
     a rendered Unicode/ASCII diagram string. Throws on render failure.  */
 export const renderDiagram = (src, opts) => {
@@ -146,11 +169,33 @@ export const renderDiagram = (src, opts) => {
         const maxHeight = termHeight > 0 ? termHeight - opts.diagramClipY : 0;
         const trailingNL = out.endsWith("\n");
         let lines = (trailingNL ? out.slice(0, -1) : out).split("\n");
-        if (maxWidth > 0)
+        let widthWarn = "";
+        let heightWarn = "";
+        if (maxWidth > 0) {
+            const widest = lines.reduce((m, l) => Math.max(m, visibleWidth(l)), 0);
+            if (widest > maxWidth)
+                widthWarn =
+                    `ase diagram: WARNING: rendered diagram width ${widest} exceeds budget ${maxWidth}; ` +
+                        "rightmost content was clipped. Please regenerate the Mermaid source to fit " +
+                        `within ${maxWidth} chars by preferring a portrait orientation ` +
+                        "(\"flowchart TB\", top-to-bottom) over landscape (\"LR\"/\"RL\"/\"BT\"), " +
+                        "reducing siblings per row, abbreviating node labels, or restructuring " +
+                        "into nested subgraph hierarchies.";
             lines = lines.map((l) => truncateAnsiLine(l, maxWidth));
-        if (maxHeight > 0 && lines.length > maxHeight)
+        }
+        if (maxHeight > 0 && lines.length > maxHeight) {
+            const overflow = lines.length - maxHeight;
+            heightWarn =
+                `ase diagram: WARNING: rendered diagram height ${lines.length} exceeds budget ${maxHeight}; ` +
+                    `bottom ${overflow} line(s) were clipped. Please regenerate the Mermaid source to fit ` +
+                    `within ${maxHeight} lines by reducing depth or splitting into multiple diagrams.`;
             lines = lines.slice(0, maxHeight);
+        }
         out = lines.join("\n") + (trailingNL ? "\n" : "");
+        if (widthWarn !== "")
+            out += "\n" + widthWarn + "\n";
+        if (heightWarn !== "")
+            out += "\n" + heightWarn + "\n";
     }
     return out;
 };

package/dst/ase-launch.js

@@ -0,0 +1,109 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+import { execa, execaSync } from "execa";
+import which from "which";
+import { Config, configSchema, parseScope } from "./ase-config.js";
+/*  list of supported tools for "ase launch <tool>"  */
+const SUPPORTED_TOOLS = ["claude"];
+/*  default statusline arguments (used when "agent.statusline" is empty/unset)  */
+const DEFAULT_STATUSLINE_ARGS = "-w 0 -m 2 '<blue>%u</blue> <red>%p</red> <black>%T</black> %s' '%m %e %t' '%P %c'";
+/*  CLI command "ase launch"  */
+export default class LaunchCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  resolve the effective "agent.statusline" from the layered
+        configuration cascade (default < user < project)  */
+    readStatuslineConfig() {
+        let statusline = "";
+        try {
+            const cfg = new Config("config", configSchema, this.log, parseScope(undefined));
+            cfg.read("lenient");
+            statusline = String(cfg.get("agent.statusline") ?? "").trim();
+        }
+        catch (_e) {
+            /*  cascade unavailable; leave default  */
+        }
+        /*  reject shell metacharacters to prevent command injection through
+            the configured value when later interpolated into a shell command  */
+        if (statusline !== "" && /[;&|`$\n\r]/.test(statusline))
+            throw new Error("invalid \"agent.statusline\" configuration value: " +
+                "must not contain shell metacharacters (; & | ` $ newline)");
+        return statusline;
+    }
+    /*  populate ASE_TERM_* environment variables (only if unset),
+        so downstream tools (e.g. the diagram renderer) get reliable
+        terminal sizing/color information regardless of the launched tool  */
+    populateTermEnv() {
+        const tty = process.stdout.isTTY;
+        if (process.env.ASE_TERM_WIDTH === undefined) {
+            const cols = tty ? process.stdout.columns : 0;
+            process.env.ASE_TERM_WIDTH = `${typeof cols === "number" && cols > 0 ? cols : 0}`;
+        }
+        if (process.env.ASE_TERM_HEIGHT === undefined) {
+            const rows = tty ? process.stdout.rows : 0;
+            process.env.ASE_TERM_HEIGHT = `${typeof rows === "number" && rows > 0 ? rows : 0}`;
+        }
+        if (process.env.ASE_TERM_COLORS === undefined) {
+            let colorMode = "none";
+            try {
+                const { stdout } = execaSync("tput", ["colors"], { reject: false });
+                const n = parseInt(stdout.trim(), 10);
+                if (!Number.isNaN(n) && n >= 256)
+                    colorMode = "ansi256";
+                else if (!Number.isNaN(n) && n >= 16)
+                    colorMode = "ansi16";
+            }
+            catch (_e) {
+                /*  ignore  */
+            }
+            process.env.ASE_TERM_COLORS = colorMode;
+        }
+    }
+    /*  handler for "ase launch <tool> [<options>...]"  */
+    async run(tool, args) {
+        /*  populate ASE_TERM_* environment variables (always, regardless of tool)  */
+        this.populateTermEnv();
+        /*  dispatch by tool name  */
+        if (tool === "claude") {
+            await which("claude").catch(() => {
+                throw new Error("required tool \"claude\" not found in $PATH");
+            });
+            let statusline = this.readStatuslineConfig();
+            if (statusline === "")
+                statusline = DEFAULT_STATUSLINE_ARGS;
+            const settingsJson = JSON.stringify({
+                statusLine: {
+                    type: "command",
+                    command: `ase statusline ${statusline}`,
+                    padding: 0
+                }
+            });
+            const result = await execa("claude", ["--settings", settingsJson, ...args], {
+                stdio: "inherit",
+                env: process.env,
+                reject: false
+            });
+            return result.exitCode ?? 0;
+        }
+        else
+            throw new Error(`unsupported tool "${tool}" ` +
+                `(expected one of: ${SUPPORTED_TOOLS.join(", ")})`);
+    }
+    /*  register commands  */
+    register(program) {
+        program
+            .command("launch <tool> [options...]")
+            .description("launch a supported tool with bootstrapped environment and settings " +
+            `(supported tools: ${SUPPORTED_TOOLS.join(", ")})`)
+            .passThroughOptions()
+            .allowUnknownOption()
+            .action(async (tool, options) => {
+            process.exit(await this.run(tool, options));
+        });
+    }
+}

package/dst/ase-mcp.js

@@ -86,54 +86,102 @@ export default class MCPCommand {
     /*  bridge stdio to a Streamable HTTP MCP endpoint on the local service  */
     async runBridge() {
         /*  ensure the service is running  */
-        const { port } = await this.ensureService();
-        /*  create MCP HTTP client  */
-        const url = new URL(`http://${HOST}:${port}/mcp`);
-        const client = new StreamableHTTPClientTransport(url);
-        /*  create MCP STDIO server  */
+        let { port } = await this.ensureService();
+        /*  create MCP STDIO server (lives for the entire bridge lifetime)  */
         const server = new StdioServerTransport();
-        /*  handle shutdown  */
-        let closed = false;
+        /*  track active client and bridge-level closed state  */
+        let client = null;
+        let closedByUs = false; /* set when we initiated the client close */
+        let bridgeDone = false; /* set when stdio side closes             */
+        /*  cleanly shut down the whole bridge  */
         const shutdown = async () => {
-            if (closed)
+            if (bridgeDone)
                 return;
-            closed = true;
+            bridgeDone = true;
+            closedByUs = true;
             await Promise.allSettled([
                 server.close(),
-                client.close()
+                client?.close()
             ]);
         };
-        /*  connect server to client (forward transport)  */
+        /*  (re-)connect the HTTP client to the service  */
+        const connectClient = async () => {
+            const url = new URL(`http://${HOST}:${port}/mcp`);
+            const next = new StreamableHTTPClientTransport(url);
+            client = next;
+            next.onmessage = (msg) => {
+                server.send(msg).catch((_err) => {
+                    const err = _err instanceof Error ? _err : new Error(String(_err));
+                    this.log.write("error", `mcp: stdout send: ${err.message}`);
+                });
+            };
+            next.onerror = (err) => {
+                this.log.write("error", `mcp: http: ${err.message}`);
+            };
+            /*  service closed the connection — try to recover  */
+            next.onclose = () => {
+                if (closedByUs || bridgeDone)
+                    return;
+                this.log.write("warning", "mcp: http connection lost — reconnecting");
+                reconnect().catch(() => { });
+            };
+            await next.start();
+        };
+        /*  reconnect loop: restart service if needed, then reconnect client  */
+        const reconnect = async (attempt = 0) => {
+            const delay = Math.min(500 * 2 ** attempt, 10000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            if (bridgeDone)
+                return;
+            try {
+                const ctx = await this.ensureService();
+                port = ctx.port;
+                closedByUs = true;
+                await client?.close();
+                closedByUs = false;
+                await connectClient();
+                this.log.write("info", "mcp: reconnected to service");
+            }
+            catch (_err) {
+                const err = _err instanceof Error ? _err : new Error(String(_err));
+                this.log.write("error", `mcp: reconnect failed: ${err.message}`);
+                reconnect(attempt + 1).catch(() => { });
+            }
+        };
+        /*  wire stdio server  */
         server.onmessage = (msg) => {
-            client.send(msg).catch((_err) => {
+            client?.send(msg).catch((_err) => {
                 const err = _err instanceof Error ? _err : new Error(String(_err));
                 this.log.write("error", `mcp: http send: ${err.message}`);
             });
         };
-        server.onerror = (_err) => {
-            const err = _err instanceof Error ? _err : new Error(String(_err));
+        server.onerror = (err) => {
             this.log.write("error", `mcp: stdio: ${err.message}`);
         };
         server.onclose = () => {
             shutdown().catch(() => { });
         };
-        /*  connect client to server (backward transport)  */
-        client.onmessage = (msg) => {
-            server.send(msg).catch((_err) => {
-                const err = _err instanceof Error ? _err : new Error(String(_err));
-                this.log.write("error", `mcp: stdout send: ${err.message}`);
-            });
-        };
-        client.onerror = (_err) => {
-            const err = _err instanceof Error ? _err : new Error(String(_err));
-            this.log.write("error", `mcp: http: ${err.message}`);
-        };
-        client.onclose = () => {
-            shutdown().catch(() => { });
-        };
-        /*  start server and client  */
+        /*  start server and initial client  */
         await server.start();
-        await client.start();
+        await connectClient();
+        /*  periodically probe the service; trigger reconnect if it is gone  */
+        const HEALTH_INTERVAL_MS = 30_000;
+        let reconnecting = false;
+        const healthTimer = setInterval(async () => {
+            if (bridgeDone || reconnecting)
+                return;
+            try {
+                const { projectId } = this.loadContext();
+                const match = await probe(port, projectId);
+                if (match !== true) {
+                    reconnecting = true;
+                    this.log.write("warning", "mcp: health check failed — reconnecting");
+                    reconnect().catch(() => { }).finally(() => { reconnecting = false; });
+                }
+            }
+            catch { /* ignore probe errors */ }
+        }, HEALTH_INTERVAL_MS);
+        healthTimer.unref();
         /*  await stdio to be closed  */
         await new Promise((resolve) => {
             const done = () => resolve();
@@ -141,6 +189,7 @@ export default class MCPCommand {
             process.stdin.once("close", done);
         });
         /*  shutdown services  */
+        clearInterval(healthTimer);
         await shutdown();
         return 0;
     }

package/dst/ase-service.js

@@ -17,7 +17,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
 import { Config, configSchema, parseScope } from "./ase-config.js";
-import { renderDiagram } from "./ase-diagram.js";
+import { renderDiagram, detectTermWidth, detectTermHeight } from "./ase-diagram.js";
 import { taskLoad, taskSave, taskDelete, taskList } from "./ase-task.js";
 import pkg from "../package.json" with { type: "json" };
 const SERVE_ENV = "ASE_SERVICE_SERVE";
@@ -231,10 +231,10 @@ export default class ServiceCommand {
                         .describe("extra horizontal clipping: subtract this many characters from `terminalWidth`"),
                     diagramClipY: z.number().int().min(0).default(0)
                         .describe("extra vertical clipping: subtract this many lines from `terminalHeight`"),
-                    terminalWidth: z.number().int().min(0).default(0)
-                        .describe("terminal width in characters; 0 disables horizontal clipping"),
-                    terminalHeight: z.number().int().min(0).default(0)
-                        .describe("terminal height in lines; 0 disables vertical clipping")
+                    terminalWidth: z.number().int().min(0).default(detectTermWidth())
+                        .describe("terminal width in characters; 0 disables horizontal clipping; defaults to ASE_TERM_WIDTH env var if set"),
+                    terminalHeight: z.number().int().min(0).default(detectTermHeight())
+                        .describe("terminal height in lines; 0 disables vertical clipping; defaults to ASE_TERM_HEIGHT env var if set")
                 }
             }, async (args) => {
                 try {
@@ -326,7 +326,7 @@ export default class ServiceCommand {
                     const message = err instanceof Error ? err.message : String(err);
                     return {
                         isError: true,
-                        content: [{ type: "text", text: `task_save: FAILED: ${message}` }]
+                        content: [{ type: "text", text: `task_save: ERROR: ${message}` }]
                     };
                 }
             });
@@ -394,7 +394,7 @@ export default class ServiceCommand {
                     const val = cfg.get("agent.persona");
                     if (val === undefined)
                         return {
-                            content: [{ type: "text", text: "" }]
+                            content: [{ type: "text", text: "engineer" }]
                         };
                     const text = String(isScalar(val) ? val.value : val);
                     return {
@@ -412,7 +412,7 @@ export default class ServiceCommand {
             mcp.registerTool("task_id", {
                 title: "ASE task id get/set",
                 description: "Get or set the active ASE task `id` for a given `session`. " +
-                    "If `id` is provided, it set the task id in the given `session`, " +
+                    "If `id` is provided, it sets the task id in the given `session`, " +
                     "otherwise it returns the current task `id` of the `session`.",
                 inputSchema: {
                     id: z.string().optional()
@@ -467,6 +467,7 @@ export default class ServiceCommand {
             method: "GET",
             path: "/stop",
             handler: (_request, h) => {
+                this.log.write("info", "service: stop requested");
                 setImmediate(async () => {
                     await server.stop({ timeout: 1000 });
                     process.exit(0);
@@ -475,6 +476,21 @@ export default class ServiceCommand {
             }
         });
         const mcpHandler = async (request, h, body) => {
+            const b = body;
+            const bParams = b?.params;
+            const bMethod = typeof b?.method === "string" ? b.method : null;
+            const bName = typeof bParams?.name === "string" ? bParams.name : null;
+            const bArgs = bParams?.arguments !== undefined ? bParams.arguments : null;
+            let bodyInfo = "";
+            if (bMethod !== null) {
+                bodyInfo = ` [${bMethod}]`;
+                if (bName !== null) {
+                    bodyInfo += ` ${bName}`;
+                    if (bArgs !== null)
+                        bodyInfo += ` ${JSON.stringify(bArgs)}`;
+                }
+            }
+            this.log.write("info", `mcp: ${request.method.toUpperCase()} ${request.path}${bodyInfo}`);
             const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
             const mcp = buildMcpServer();
             request.raw.res.on("close", () => {
@@ -531,6 +547,7 @@ export default class ServiceCommand {
         try {
             await server.start();
             persistPort(ctx.svc, ctx.port);
+            this.log.write("info", `service: listening on port ${ctx.port}`);
         }
         catch (err) {
             const e = err;
@@ -552,6 +569,7 @@ export default class ServiceCommand {
                 return;
             if (Date.now() - lastActivity > IDLE_MS) {
                 stopping = true;
+                this.log.write("info", "service: idle timeout reached, stopping");
                 try {
                     await server.stop({ timeout: 1000 });
                     clearPort(ctx.svc);

package/dst/ase-setup.js

@@ -22,26 +22,48 @@ export default class SetupCommand {
     }
     /*  run a sub-process, suppressing output on success and emitting it on failure  */
     async run(cmd, args, opts = {}) {
-        const { cwd, quiet = false } = opts;
+        const { cwd, quiet = false, retries = 1, ignoreError } = opts;
         this.log.write("info", `setup: $ ${cmd} ${args.join(" ")}` +
             (cwd !== undefined ? ` (cwd: ${cwd})` : ""));
-        if (quiet) {
-            await execa(cmd, args, { stdio: "ignore", cwd, reject: false });
-            return;
-        }
-        await execa(cmd, args, { stdio: "pipe", cwd }).catch((err) => {
-            const exitCode = typeof err?.exitCode === "number" ? err.exitCode : -1;
-            this.log.write("error", `setup: command failed: exit code: ${exitCode}`);
-            if (typeof err?.stdout === "string" && err.stdout.length > 0) {
-                this.log.write("error", "setup: command failed: stdout:");
-                process.stdout.write(err.stdout);
+        for (let i = 0; i < retries; i++) {
+            const final = (i === retries - 1);
+            try {
+                if (quiet) {
+                    const result = await execa(cmd, args, { stdio: "ignore", cwd, reject: false });
+                    if (typeof result.exitCode === "number" && result.exitCode !== 0 && !final) {
+                        this.log.write("info", `setup: attempt ${i + 1}/${retries} failed for "${cmd} ${args.join(" ")}" ` +
+                            `(exit code: ${result.exitCode}): retrying...`);
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        continue;
+                    }
+                    return;
+                }
+                await execa(cmd, args, { stdio: "pipe", cwd });
+                return;
             }
-            if (typeof err?.stderr === "string" && err.stderr.length > 0) {
-                this.log.write("error", "setup: command failed: stderr:");
-                process.stderr.write(err.stderr);
+            catch (err) {
+                if (!final) {
+                    this.log.write("info", `setup: attempt ${i + 1}/${retries} failed for "${cmd} ${args.join(" ")}": retrying...`);
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    continue;
+                }
+                if (ignoreError !== undefined) {
+                    this.log.write("info", `setup: ${ignoreError} (skipped)`);
+                    return;
+                }
+                const exitCode = typeof err?.exitCode === "number" ? err.exitCode : -1;
+                this.log.write("error", `setup: command failed: exit code: ${exitCode}`);
+                if (typeof err?.stdout === "string" && err.stdout.length > 0) {
+                    this.log.write("error", "setup: command failed: stdout:");
+                    process.stdout.write(err.stdout);
+                }
+                if (typeof err?.stderr === "string" && err.stderr.length > 0) {
+                    this.log.write("error", "setup: command failed: stderr:");
+                    process.stderr.write(err.stderr);
+                }
+                throw err;
             }
-            throw err;
-        });
+        }
     }
     /*  handler for "ase setup install"  */
     async doInstall(dev) {
@@ -51,7 +73,7 @@ export default class SetupCommand {
             `installing ASE Claude Code plugin (origin: ${dev ? "local" : "remote"})`);
         const source = dev ? process.cwd() : "rse/ase";
         await this.run("claude", ["plugin", "marketplace", "add", source]);
-        await this.run("claude", ["plugin", "install", "ase@ase"]);
+        await this.run("claude", ["plugin", "install", "ase@ase"], { retries: 3 });
         return 0;
     }
     /*  handler for "ase setup update"  */
@@ -72,8 +94,8 @@ export default class SetupCommand {
                 but there is no version change in the plugin manifest,
                 so just re-install the plugin to let Claude Code update its copy  */
             this.log.write("info", "setup: update[dev]: re-install ASE Claude Code plugin (origin: local)");
-            await this.run("claude", ["plugin", "uninstall", "ase@ase"]);
-            await this.run("claude", ["plugin", "install", "ase@ase"]);
+            await this.run("claude", ["plugin", "uninstall", "ase@ase"], { ignoreError: "ASE Claude Code plugin not installed" });
+            await this.run("claude", ["plugin", "install", "ase@ase"], { retries: 3 });
         }
         else {
             /*  perform NPM version check  */
@@ -104,8 +126,8 @@ export default class SetupCommand {
         /*  uninstall ASE Claude Code plugin  */
         this.log.write("info", `setup: uninstall${dev ? "[dev]" : ""}: ` +
             `uninstalling ASE Claude Code plugin (origin: ${dev ? "local" : "remote"})`);
-        await this.run("claude", ["plugin", "uninstall", "ase@ase"]);
-        await this.run("claude", ["plugin", "marketplace", "remove", "ase"]);
+        await this.run("claude", ["plugin", "uninstall", "ase@ase"], { ignoreError: "ASE Claude Code plugin not installed" });
+        await this.run("claude", ["plugin", "marketplace", "remove", "ase"], { ignoreError: "ASE Claude Code plugin marketplace not registered" });
         /*  uninstall ASE CLI tool (non-development only)  */
         if (!dev) {
             this.log.write("info", "setup: uninstall: uninstalling ASE CLI tool (origin: remote)");

package/dst/ase-statusline.js

@@ -4,10 +4,28 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
+import { InvalidArgumentError } from "commander";
 import { execaSync } from "execa";
+import { Chalk } from "chalk";
 import { Config, configSchema, parseScope } from "./ase-config.js";
+/*  forced-color chalk instance: stdout is a pipe under Claude Code,
+    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 });
+/*  set of valid <color>...</color> markup names (chalk basic foreground colors plus "default")  */
+const COLORS = new Set([
+    "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "default"
+]);
+/*  custom argument parser for Commander: non-negative integer  */
+const parseInteger = (name) => (value) => {
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n < 0)
+        throw new InvalidArgumentError(`${name} must be a non-negative integer`);
+    return n;
+};
 /*  read stdin into a single string  */
 const readStdin = async () => {
     const chunks = [];
@@ -29,6 +47,114 @@ const detectTermWidth = () => {
     }
     return width;
 };
+/*  format a token count as a compact human-readable string (e.g. 334k, 104.9M)  */
+const formatTokens = (n) => {
+    if (!Number.isFinite(n) || n < 0)
+        return "0";
+    if (n >= 1_000_000_000)
+        return `${(n / 1_000_000_000).toFixed(1)}G`;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}k`;
+    return `${n}`;
+};
+/*  format a millisecond duration as a compact human-readable string (e.g. 6d 12hr 7m, 4hr 27m, 12m 30s)  */
+const formatDurationMs = (ms) => {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "0s";
+    const totalSec = Math.floor(ms / 1000);
+    const days = Math.floor(totalSec / 86400);
+    const hours = Math.floor((totalSec % 86400) / 3600);
+    const mins = Math.floor((totalSec % 3600) / 60);
+    const secs = totalSec % 60;
+    if (days > 0)
+        return `${days}d ${hours}hr ${mins}m`;
+    if (hours > 0)
+        return `${hours}hr ${mins}m`;
+    if (mins > 0)
+        return `${mins}m ${secs}s`;
+    return `${secs}s`;
+};
+/*  format a wall-clock duration as elapsed hours+minutes (e.g. 92hr 40m), without day rollover  */
+const formatHoursMinutes = (ms) => {
+    if (!Number.isFinite(ms) || ms < 0)
+        return "0hr 0m";
+    const totalMin = Math.floor(ms / 60000);
+    const hours = Math.floor(totalMin / 60);
+    const mins = totalMin % 60;
+    return `${hours}hr ${mins}m`;
+};
+/*  format an ISO timestamp as a remaining-time relative to now (e.g. 4hr 27m, 6d 12hr 7m)  */
+const formatTimeUntil = (iso) => {
+    const target = Date.parse(iso);
+    if (!Number.isFinite(target))
+        return "";
+    const delta = target - Date.now();
+    if (delta <= 0)
+        return "0m";
+    return formatDurationMs(delta);
+};
+/*  format a USD cost as a dollar string with 2 decimals (e.g. $54.44)  */
+const formatCostUsd = (n) => {
+    if (!Number.isFinite(n) || n < 0)
+        return "$0.00";
+    return `$${n.toFixed(2)}`;
+};
+/*  format a byte count as a compact human-readable string (e.g. 33.2G, 512M)  */
+const formatBytes = (n) => {
+    if (!Number.isFinite(n) || n < 0)
+        return "0";
+    if (n >= 1024 ** 3)
+        return `${(n / 1024 ** 3).toFixed(1)}G`;
+    if (n >= 1024 ** 2)
+        return `${(n / 1024 ** 2).toFixed(1)}M`;
+    if (n >= 1024)
+        return `${(n / 1024).toFixed(1)}k`;
+    return `${n}`;
+};
+/*  probe local git status for the given working directory  */
+const probeGit = (cwd) => {
+    try {
+        const branch = execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1000 })
+            .toString("utf8").trim();
+        const porc = execFileSync("git", ["-C", cwd, "status", "--porcelain"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1000 })
+            .toString("utf8");
+        const lines = porc.split("\n").filter((l) => l.length > 0);
+        const untracked = lines.filter((l) => l.startsWith("??")).length;
+        const dirty = lines.length > 0;
+        let added = 0;
+        let removed = 0;
+        try {
+            const shortstat = execFileSync("git", ["-C", cwd, "diff", "--shortstat", "HEAD"], { stdio: ["ignore", "pipe", "ignore"], timeout: 1000 })
+                .toString("utf8");
+            const mAdd = shortstat.match(/(\d+)\s+insertion/);
+            const mDel = shortstat.match(/(\d+)\s+deletion/);
+            if (mAdd !== null)
+                added = Number.parseInt(mAdd[1], 10);
+            if (mDel !== null)
+                removed = Number.parseInt(mDel[1], 10);
+        }
+        catch (_e) {
+            /*  no HEAD yet or git failure; leave counts at 0  */
+        }
+        return { branch, dirty, untracked, added, removed };
+    }
+    catch (_e) {
+        return { branch: "", dirty: false, untracked: 0, added: 0, removed: 0 };
+    }
+};
+/*  probe local memory usage in bytes (used/total) using OS-portable helpers  */
+const probeMemory = () => {
+    try {
+        const total = os.totalmem();
+        const free = os.freemem();
+        return { used: total - free, total };
+    }
+    catch (_e) {
+        return { used: 0, total: 0 };
+    }
+};
 /*  command-line handling  */
 export default class StatuslineCommand {
     log;
@@ -40,7 +166,15 @@ export default class StatuslineCommand {
         program
             .command("statusline")
             .description("Render Claude Code statusline from stdin JSON")
-            .action(async () => {
+            .option("-w, --width <n>", "force terminal width to <n> characters (0 = auto-detect via /dev/tty)", parseInteger("--width"), 0)
+            .option("-m, --margin <n>", "reduce maximum used terminal width by <n> characters on each side", parseInteger("--margin"), 2)
+            .option("--no-icons", "disable icons in placeholder rendering")
+            .option("--no-labels", "disable labels in front of bold values")
+            .argument("[lines...]", "one or more template lines with %u %p %T %s %m %e %t %P %c %C %L %N %a %r " +
+            "%S %D %W %Q %H %X %b %g %G %d %M %V %o placeholders and <color>...</color> markup " +
+            "(color: black, red, green, yellow, blue, magenta, cyan, white, default) " +
+            "(default: single line \"%m %e %t\")")
+            .action(async (lines, opts) => {
             /*  read all of stdin  */
             const input = await readStdin();
             /*  parse JSON data  */
@@ -53,78 +187,278 @@ export default class StatuslineCommand {
                 this.log.write("error", `statusline: invalid JSON on stdin: ${message}`);
                 process.exit(1);
             }
-            /*  fetch information from data  */
-            const dir = path.basename(data.workspace?.current_dir ?? "");
-            const model = data.model?.display_name ?? "";
-            const pct = Math.floor(data.context_window?.used_percentage ?? 0);
-            const effort = data.effort?.level ?? "unknown";
-            const thinking = (data.thinking?.enabled ?? false) === true ? "yes" : "no";
-            const sessionId = data.session_id ?? "unknown";
-            /*  optionally determine ASE task id and persona style via in-process Config  */
-            let taskId = process.env.ASE_TASK_ID ?? "";
-            let persona = process.env.ASE_PERSONA_STYLE ?? "";
-            try {
-                const cfg = new Config("config", configSchema, this.log, parseScope(`session:${sessionId}`));
-                cfg.read("lenient");
-                const t = String(cfg.get("agent.task") ?? "").trim();
-                const p = String(cfg.get("agent.persona") ?? "").trim();
-                if (t !== "")
-                    taskId = t;
-                if (p !== "")
-                    persona = p;
-            }
-            catch (_e) {
-                /*  cascade unavailable; keep env-var fallbacks  */
-            }
-            /*  optionally determine terminal width  */
-            const width = detectTermWidth();
-            /*  configure ANSI sequences  */
-            const RESET = "\x1b[0m";
-            const BOLD = "\x1b[1m";
-            const BLACK = "\x1b[30m";
-            const BLUE = "\x1b[34m";
-            const YELLOW = "\x1b[33m";
-            const RED = "\x1b[31m";
-            /*  determine context bar information  */
-            const barSize = 20;
-            const barColor = pct >= 80 ? RED : pct >= 60 ? YELLOW : pct >= 40 ? BLUE : RESET;
-            const filled = Math.round(pct / 100 * barSize);
-            const bar = "█".repeat(filled) + "░".repeat(barSize - filled);
-            /*  generate output  */
-            let output = "";
-            output += `${BLUE}※ user: ${BOLD}${process.env.USER ?? process.env.LOGNAME ?? "unknown"}${RESET} `;
-            if (width > 0 && width < 30)
-                output += "\n";
-            output += `${RED}⚑ project: ${BOLD}${dir}${RESET} `;
-            if (width > 0 && width < 60)
-                output += "\n";
-            if (taskId !== "") {
-                output += `${BLACK}◉ task: ${BOLD}${taskId}${RESET} `;
-                if (width > 0 && width < 90)
-                    output += "\n";
-            }
-            output += `⏻ session: ${BOLD}${sessionId}${RESET}\n`;
-            output += `⚙ model: ${BOLD}${model}${RESET} `;
-            if (width > 0 && width < 30)
-                output += "\n";
-            output += `⚒ effort: ${BOLD}${effort}${RESET} `;
-            if (width > 0 && width < 60)
-                output += "\n";
-            output += `⚛ thinking: ${BOLD}${thinking}${RESET}\n`;
-            if (persona !== "") {
-                output += `☯ persona: ${BOLD}${persona}${RESET} `;
-                if (width > 0 && width < 30)
-                    output += "\n";
+            /*  determine effective terminal width and budget  */
+            const width = opts.width > 0 ? opts.width : detectTermWidth();
+            const budget = width > 0 ? width - 2 * opts.margin : 0;
+            /*  shared output state and append helper with auto-wrap;
+                the helper itself strips ANSI CSI escape sequences to
+                measure the raw visible width of the chunk  */
+            let out = "";
+            let col = 0;
+            const appendOutput = (ansi) => {
+                /*  eslint-disable-next-line no-control-regex  */
+                const raw = ansi.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+                if (budget > 0 && col > 0 && col + raw.length > budget) {
+                    out += "\n";
+                    col = 0;
+                }
+                out += ansi;
+                col += raw.length;
+            };
+            /*  active <color> span state: when non-null, renderer/literal output is buffered
+                instead of appended directly, and flushed via c[color](buf) on </color>  */
+            let span = null;
+            const emit = (chunk) => {
+                if (span !== null)
+                    span.buf += chunk;
+                else
+                    appendOutput(chunk);
+            };
+            /*  helper to build the "<icon> <label>: " prefix subject to --no-icons / --no-labels  */
+            const prefix = (icon, label) => {
+                const i = opts.icons ? `${icon} ` : "";
+                const l = opts.labels ? `${label}: ` : "";
+                return `${i}${l}`;
+            };
+            /*  determine effective template lines  */
+            const tmpl = lines.length > 0 ? lines : ["%m %e %t"];
+            /*  lazy memoized probes for cross-renderer values: each is computed at most
+                once per run and only when first requested by a renderer (or by the
+                post-loop tmux publish for the Config cascade)  */
+            let sessCache = null;
+            const getSession = () => {
+                if (sessCache === null)
+                    sessCache = data.session_name ?? data.session_id ?? "unknown";
+                return sessCache;
+            };
+            let cfgCache = null;
+            const getCfg = () => {
+                if (cfgCache !== null)
+                    return cfgCache;
+                let taskId = process.env.ASE_TASK_ID ?? "";
+                let persona = process.env.ASE_PERSONA_STYLE ?? "";
+                try {
+                    const cfg = new Config("config", configSchema, this.log, parseScope(`session:${getSession()}`));
+                    cfg.read("lenient");
+                    const t = String(cfg.get("agent.task") ?? "").trim();
+                    const p = String(cfg.get("agent.persona") ?? "").trim();
+                    if (t !== "")
+                        taskId = t;
+                    if (p !== "")
+                        persona = p;
+                }
+                catch (_e) {
+                    /*  cascade unavailable; keep env-var fallbacks  */
+                }
+                cfgCache = { taskId, persona };
+                return cfgCache;
+            };
+            let gitCache = null;
+            const getGit = () => {
+                if (gitCache === null)
+                    gitCache = probeGit(data.workspace?.current_dir ?? "");
+                return gitCache;
+            };
+            let memCache = null;
+            const getMem = () => {
+                if (memCache === null)
+                    memCache = probeMemory();
+                return memCache;
+            };
+            /*  identifier to renderer map: each callback fetches its own information
+                directly from data (or via the lazy helpers above for shared values)  */
+            const renderers = {
+                u: () => {
+                    const user = process.env.USER ?? process.env.LOGNAME ?? "unknown";
+                    emit(`${prefix("※", "user")}${c.bold(user)}`);
+                },
+                p: () => {
+                    const dir = path.basename(data.workspace?.current_dir ?? "");
+                    emit(`${prefix("⚑", "project")}${c.bold(dir)}`);
+                },
+                T: () => {
+                    const { taskId } = getCfg();
+                    if (taskId !== "")
+                        emit(`${prefix("◉", "task")}${c.bold(taskId)}`);
+                },
+                s: () => emit(`${prefix("⏻", "session")}${c.bold(getSession())}`),
+                m: () => {
+                    const model = data.model?.display_name ?? "";
+                    emit(`${prefix("⚙", "model")}${c.bold(model)}`);
+                },
+                e: () => {
+                    const effort = data.effort?.level ?? "unknown";
+                    emit(`${prefix("⚒", "effort")}${c.bold(effort)}`);
+                },
+                t: () => {
+                    const thinking = (data.thinking?.enabled ?? false) === true ? "yes" : "no";
+                    emit(`${prefix("⚛", "thinking")}${c.bold(thinking)}`);
+                },
+                P: () => {
+                    const { persona } = getCfg();
+                    if (persona !== "")
+                        emit(`${prefix("☯", "persona")}${c.bold(persona)}`);
+                },
+                c: () => {
+                    const pct = Math.floor(data.context_window?.used_percentage ?? 0);
+                    const barSize = 20;
+                    const filled = Math.round(pct / 100 * barSize);
+                    const bar = "█".repeat(filled) + "░".repeat(barSize - filled);
+                    emit(`${prefix("◔", "context")}${bar} ${pct}%`);
+                },
+                a: () => {
+                    const linesAdded = data.cost?.total_lines_added ?? 0;
+                    emit(`${prefix("⊕", "added")}${c.bold(linesAdded)}`);
+                },
+                r: () => {
+                    const linesRemoved = data.cost?.total_lines_removed ?? 0;
+                    emit(`${prefix("⊖", "removed")}${c.bold(linesRemoved)}`);
+                },
+                C: () => {
+                    const ctxIn = data.context_window?.current_usage?.input_tokens ?? 0;
+                    const ctxCcIn = data.context_window?.current_usage?.cache_creation_input_tokens ?? 0;
+                    const ctxCrIn = data.context_window?.current_usage?.cache_read_input_tokens ?? 0;
+                    const tokensCur = ctxIn + ctxCcIn + ctxCrIn;
+                    if (tokensCur > 0)
+                        emit(`${prefix("◇", "tokens")}${c.bold(formatTokens(tokensCur))}`);
+                },
+                L: () => {
+                    const pct = Math.floor(data.context_window?.used_percentage ?? 0);
+                    const ctxIn = data.context_window?.current_usage?.input_tokens ?? 0;
+                    const ctxCcIn = data.context_window?.current_usage?.cache_creation_input_tokens ?? 0;
+                    const ctxCrIn = data.context_window?.current_usage?.cache_read_input_tokens ?? 0;
+                    const tokensCur = ctxIn + ctxCcIn + ctxCrIn;
+                    const tokensLim = pct > 0 && tokensCur > 0 ? Math.round(tokensCur * 100 / pct) : 0;
+                    if (tokensLim > 0)
+                        emit(`${prefix("◆", "limit")}${c.bold(formatTokens(tokensLim))}`);
+                },
+                N: () => {
+                    const tokensCum = (data.context_window?.total_input_tokens ?? 0) +
+                        (data.context_window?.total_output_tokens ?? 0);
+                    if (tokensCum > 0)
+                        emit(`${prefix("Σ", "total")}${c.bold(formatTokens(tokensCum))}`);
+                },
+                S: () => {
+                    const pct5h = data.rate_limits?.five_hour?.used_percentage;
+                    if (pct5h !== undefined)
+                        emit(`${prefix("⏲", "session")}${c.bold(`${pct5h.toFixed(1)}%`)}`);
+                },
+                D: () => {
+                    const until5h = data.rate_limits?.five_hour?.resets_at ?? "";
+                    const s = formatTimeUntil(until5h);
+                    if (s !== "")
+                        emit(`${prefix("⏱", "session-resets")}${c.bold(s)}`);
+                },
+                W: () => {
+                    const pctWk = data.rate_limits?.seven_day?.used_percentage;
+                    if (pctWk !== undefined)
+                        emit(`${prefix("⏲", "weekly")}${c.bold(`${pctWk.toFixed(1)}%`)}`);
+                },
+                Q: () => {
+                    const untilWk = data.rate_limits?.seven_day?.resets_at ?? "";
+                    const s = formatTimeUntil(untilWk);
+                    if (s !== "")
+                        emit(`${prefix("⏱", "weekly-resets")}${c.bold(s)}`);
+                },
+                H: () => {
+                    const sessDurMs = data.cost?.total_duration_ms ?? 0;
+                    if (sessDurMs > 0)
+                        emit(`${prefix("⏱", "elapsed")}${c.bold(formatHoursMinutes(sessDurMs))}`);
+                },
+                X: () => {
+                    const sessCost = data.cost?.total_cost_usd;
+                    if (sessCost !== undefined)
+                        emit(`${prefix("$", "cost")}${c.bold(formatCostUsd(sessCost))}`);
+                },
+                b: () => {
+                    const g = getGit();
+                    const label = g.branch !== "" ? g.branch : "no git";
+                    emit(`${prefix("⎇", "branch")}${c.bold(label)}`);
+                },
+                g: () => {
+                    const g = getGit();
+                    if (g.branch !== "")
+                        emit(`${prefix("±", "changed")}${c.bold(`+${g.added}/-${g.removed}`)}`);
+                },
+                G: () => {
+                    const g = getGit();
+                    if (g.branch !== "")
+                        emit(`${prefix("⁈", "untracked")}${c.bold(String(g.untracked))}`);
+                },
+                d: () => {
+                    const cwd = data.workspace?.current_dir ?? "";
+                    if (cwd !== "")
+                        emit(`${prefix("▶", "cwd")}${c.bold(cwd)}`);
+                },
+                M: () => {
+                    const m = getMem();
+                    if (m.total > 0)
+                        emit(`${prefix("⛁", "mem")}${c.bold(`${formatBytes(m.used)}/${formatBytes(m.total)}`)}`);
+                },
+                V: () => {
+                    const ccVersion = data.version ?? "";
+                    if (ccVersion !== "")
+                        emit(`${prefix("⎈", "version")}${c.bold(ccVersion)}`);
+                },
+                o: () => {
+                    const styleName = data.output_style?.name ?? "";
+                    if (styleName !== "")
+                        emit(`${prefix("≡", "style")}${c.bold(styleName)}`);
+                }
+            };
+            /*  walk each template line and render  */
+            for (const line of tmpl) {
+                let i = 0;
+                while (i < line.length) {
+                    const ch = line[i];
+                    const next = line[i + 1];
+                    if (ch === "<") {
+                        const m = line.slice(i).match(/^<(\/?)([a-z]+)>/);
+                        if (m !== null && COLORS.has(m[2])) {
+                            if (m[1] === "/") {
+                                if (span !== null) {
+                                    const wrapped = span.color === "default" ?
+                                        span.buf :
+                                        (c[span.color])(span.buf);
+                                    span = null;
+                                    appendOutput(wrapped);
+                                }
+                            }
+                            else if (span === null)
+                                span = { color: m[2], buf: "" };
+                            i += m[0].length;
+                            continue;
+                        }
+                    }
+                    if (ch === "%" && next !== undefined && renderers[next] !== undefined) {
+                        renderers[next]();
+                        i += 2;
+                    }
+                    else {
+                        emit(ch);
+                        i += 1;
+                    }
+                }
+                /*  flush any unterminated span at end of line  */
+                if (span !== null) {
+                    const wrapped = span.color === "default" ?
+                        span.buf :
+                        (c[span.color])(span.buf);
+                    span = null;
+                    appendOutput(wrapped);
+                }
+                out += "\n";
+                col = 0;
             }
-            output += `${barColor}◔ context: ${bar} ${pct}%${RESET}\n`;
             /*  send output  */
-            process.stdout.write(output);
+            process.stdout.write(out);
             /*  optionally publish task id to the calling tmux pane as a per-pane user
                 option, so someone (like claudeX) can pick it up via #{@ase_task_id}  */
             if (process.env.TMUX !== undefined
                 && process.env.TMUX !== ""
                 && process.env.TMUX_PANE !== undefined
                 && process.env.TMUX_PANE !== "") {
+                const { taskId } = getCfg();
                 const tid = taskId !== "" ? taskId : "default";
                 execaSync("tmux", ["set-option", "-p", "-t", process.env.TMUX_PANE,
                     "@ase_task_id", tid], { stdio: "ignore", reject: false });

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.0.19",
+    "version":                              "0.0.21",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",
@@ -18,9 +18,8 @@
     "devDependencies": {
         "eslint":                           "9.39.4",
         "@eslint/js":                       "9.39.4",
-        "@typescript-eslint/parser":        "8.59.1",
-        "@typescript-eslint/eslint-plugin": "8.59.1",
-        "eslint-plugin-n":                  "17.24.0",
+        "@typescript-eslint/parser":        "8.59.2",
+        "@typescript-eslint/eslint-plugin": "8.59.2",
         "eslint-plugin-promise":            "7.3.0",
         "eslint-plugin-import":             "2.32.0",
         "neostandard":                      "0.13.0",
@@ -38,18 +37,18 @@
     "dependencies": {
         "commander":                        "14.0.3",
         "yaml":                             "2.8.4",
-        "valibot":                          "1.3.1",
+        "valibot":                          "1.4.0",
         "execa":                            "9.6.1",
         "mkdirp":                           "3.0.1",
-        "@hapi/hapi":                       "21.4.8",
-        "axios":                            "1.15.2",
+        "@hapi/hapi":                       "21.4.9",
+        "axios":                            "1.16.0",
         "beautiful-mermaid":                "1.1.3",
         "cli-table3":                       "0.6.5",
         "chalk":                            "5.6.2",
         "pretty-ms":                        "9.3.0",
         "luxon":                            "3.7.2",
         "@modelcontextprotocol/sdk":        "1.29.0",
-        "zod":                              "4.4.2",
+        "zod":                              "4.4.3",
         "which":                            "6.0.1"
     },
     "engines": {