@rse/ase 0.0.19 → 0.0.20

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.20",
     "license":                              "GPL-3.0-only",
     "author": {
         "name":                             "Dr. Ralf S. Engelschall",