@cruxy/cli 0.25.0 → 0.26.0

package/dist/approval/prompt.d.ts

@@ -29,6 +29,12 @@ export interface PromptIO {
     readLine(): Promise<string>;
     /** Whether to emit ANSI color. */
     color: boolean;
+    /**
+     * Terminal columns (U.12). Optional so every existing PromptIO literal is
+     * unchanged; when absent the render resolves the width itself. Threaded so a
+     * narrow prompt reflows the command and never truncates the risk marker.
+     */
+    columns?: number;
 }
 /**
  * Render the action, read one key, and map it to a {@link PromptChoice}. `n`/`t`
@@ -37,6 +43,6 @@ export interface PromptIO {
  */
 export declare function promptForApproval(request: ApprovalRequest, io: PromptIO): Promise<PromptChoice>;
 /** Render the full prompt block: header, detail (diff or command+cwd), choices. */
-export declare function render(request: ApprovalRequest, color: boolean): string;
+export declare function render(request: ApprovalRequest, color: boolean, columns?: number): string;
 /** Build the real PromptIO: prompt to stderr, read keys/lines from stdin. */
 export declare function defaultPromptIO(color: boolean): PromptIO;

package/dist/approval/prompt.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { readSingleKey } from "../components/input.js";
 import { renderActionPreview } from "../render/diff.js";
+import { resolveColumns } from "../render/capabilities.js";
+import { fitMiddle, reflow, visibleWidth } from "../render/layout.js";
 import { themeForColor } from "../theme/index.js";
 /**
  * Render the action, read one key, and map it to a {@link PromptChoice}. `n`/`t`
@@ -8,7 +10,7 @@ import { themeForColor } from "../theme/index.js";
  * is a reject.
  */
 export async function promptForApproval(request, io) {
-    io.write(render(request, io.color));
+    io.write(render(request, io.color, io.columns ?? resolveColumns()));
     const key = (await io.readKey()).toLowerCase();
     io.write("\n");
     switch (key) {
@@ -34,21 +36,41 @@ export async function promptForApproval(request, io) {
     }
 }
 /** Render the full prompt block: header, detail (diff or command+cwd), choices. */
-export function render(request, color) {
+export function render(request, color, columns = resolveColumns()) {
     const t = themeForColor(color);
     const destructive = request.tier === "destructive";
-    // Risk survives all three degradations (U.11): the mark carries it by *shape*
-    // (`!` vs `?`) for NO_COLOR, and the label carries it by *word*
-    // (`(destructive)` / `(mutate)` / `(read)`) — never by hue alone, and legible
-    // to a screen reader that would otherwise read `!` as "exclamation mark".
+    // Risk survives all FOUR degradations now (U.11 color/unicode/reader + U.12
+    // width): the mark carries it by *shape* (`!` vs `?`) for NO_COLOR, the label
+    // by *word* (`(destructive)` / `(mutate)` / `(read)`) — never by hue alone —
+    // and under narrow width the header line that holds both is emitted WHOLE,
+    // never passed through a right-truncating fit that could drop the label.
     const mark = destructive ? t.danger(t.strong("!")) : t.warning("?");
     const label = tierLabel(request.tier, t);
     const lines = [];
-    lines.push(`${mark} cruxy wants to ${t.strong(request.summary)}${label}`);
-    lines.push(detail(request, t));
+    lines.push(...header(request.summary, mark, label, t, columns));
+    lines.push(detail(request, t, columns));
     lines.push(choices(request.scope, t));
     return lines.filter((l) => l !== "").join("\n") + " ";
 }
+/**
+ * The header, width-aware (U.12). Wide: the one inline line `! cruxy wants to
+ * <summary> (destructive)`. Narrow: the risk (mark + tier label) stands on its
+ * own line — emitted whole, never truncated — and the summary reflows beneath
+ * it, so the security-relevant part is always visible while the description
+ * wraps rather than soft-wrapping into a torn line.
+ */
+function header(summary, mark, label, t, width) {
+    const inline = `${mark} cruxy wants to ${t.strong(summary)}${label}`;
+    if (visibleWidth(inline) <= width)
+        return [inline];
+    // The risk line (mark + tier word, e.g. `! (destructive)`) is short and is
+    // NEVER passed through fit(): if it overflows an absurdly narrow terminal it
+    // wraps (nothing dropped) rather than losing its tier. The action prose +
+    // summary reflow beneath it.
+    const riskLine = `${mark}${label}`;
+    const body = reflow(`cruxy wants to ${summary}`, Math.max(1, width - 2)).map((l) => `  ${t.strong(l)}`);
+    return [riskLine, ...body];
+}
 /** The worded risk tag, colored by tier — always present, so meaning never
  * rides on the `!`/`?` shape or its color alone. */
 function tierLabel(tier, t) {
@@ -62,17 +84,28 @@ function tierLabel(tier, t) {
     }
 }
 /** The action detail: a diff for file actions, the command + cwd for shell/test. */
-function detail(request, t) {
+function detail(request, t, width) {
     if (request.action.kind === "shell" || request.action.kind === "test") {
-        return [
-            `  ${t.muted("$")} ${request.action.command ?? ""}`,
-            `  ${t.muted(`in ${request.cwd}`)}`,
-        ].join("\n");
+        // The command is REFLOWED, never truncated (U.12): you always see the whole
+        // thing you are authorizing — it wraps across as many lines as it needs. The
+        // cwd (a path) middle-truncates so its leaf survives.
+        const command = request.action.command ?? "";
+        const wrapped = reflow(command, Math.max(1, width - 4));
+        const cmdLines = [
+            `  ${t.muted("$")} ${wrapped[0] ?? ""}`,
+            ...wrapped.slice(1).map((l) => `    ${l}`),
+        ];
+        const cwd = fitMiddle(request.cwd, Math.max(1, width - 5), t.glyph.ellipsis);
+        return [...cmdLines, `  ${t.muted(`in ${cwd}`)}`].join("\n");
     }
     if (request.action.kind === "mcp") {
         // The server runs UNSANDBOXED with the user's privileges — say so at the
-        // point of the call, not just at trust time.
-        return `  ${t.muted(`external MCP server "${request.action.server ?? ""}" — runs unsandboxed with your privileges`)}`;
+        // point of the call, not just at trust time. Reflowed so the whole warning
+        // survives narrow width (it must not be the part that gets clipped).
+        const note = `external MCP server "${request.action.server ?? ""}" — runs unsandboxed with your privileges`;
+        return reflow(note, Math.max(1, width - 2))
+            .map((l) => `  ${t.muted(l)}`)
+            .join("\n");
     }
     if (request.action.kind === "vcs" && request.action.root) {
         // C.26 Step 4 (⚖︎JC-4): name the acting root alongside the resolved owner/repo
@@ -80,12 +113,12 @@ function detail(request, t) {
         // PR acts in and the real API destination before approving.
         return [
             `  ${t.muted(`root ${request.action.root}`)}`,
-            renderActionPreview(request.action.preview, t),
+            renderActionPreview(request.action.preview, t, width),
         ]
             .filter((l) => l !== "")
             .join("\n");
     }
-    return renderActionPreview(request.action.preview, t);
+    return renderActionPreview(request.action.preview, t, width);
 }
 /** The choices line, including a short label of what an `a` grant would cover. */
 function choices(scope, t) {
@@ -117,6 +150,8 @@ export function defaultPromptIO(color) {
         readKey: () => readSingleKey(),
         readLine: readLineFromStdin,
         color,
+        // The prompt writes to stderr — width from stderr's own columns (U.12).
+        columns: resolveColumns(process.stderr),
     };
 }
 /** Read one line in cooked mode; "" on EOF. */

package/dist/cli/commands/skills.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { getSkillService, resetSkillServices } from "../../skills/index.js";
 import { shouldUseColor } from "../../errors/index.js";
+import { kvStack, resolveColumns } from "../../render/index.js";
 import { themeForColor } from "../../theme/index.js";
 import { logger } from "../../utils/logger.js";
 /**
@@ -34,8 +35,15 @@ export function skillsCommand() {
             return;
         }
         logger.print(`\n${t.heading("sources")} ${t.muted("(precedence, high to low)")}`);
-        for (const { source, dir } of status.sources) {
-            logger.print(`  ${t.kv(source, t.muted(dir), 8)}`);
+        // Aligned `source  dir` columns when there's room; at narrow width the
+        // dir paths would collide with the key column, so kvStack stacks each
+        // pair instead (U.12) — the paths stay readable rather than truncating.
+        const rows = status.sources.map((s) => ({
+            key: s.source,
+            value: t.muted(s.dir),
+        }));
+        for (const line of kvStack(rows, resolveColumns(process.stdout) - 2, t)) {
+            logger.print(`  ${line}`);
         }
         logger.print("");
         if (status.errors.length === 0) {

package/dist/cli/repl.js

@@ -5,10 +5,14 @@ import { runGatedShell } from "../tools/shell/exec.js";
 import { addRootToWorkspace } from "../workspace/index.js";
 import { themeForColor } from "../theme/index.js";
 import { formatError, fromUnknown, isVerbose, shouldUseColor, } from "../errors/index.js";
-import { createRenderer } from "../render/index.js";
+import { createRenderer, fit, resolveColumns, } from "../render/index.js";
 import { logger } from "../utils/logger.js";
 /** The REPL prompts on stdout; its chrome resolves against stdout's color. */
 const theme = themeForColor(shouldUseColor(process.stdout));
+/** Fit a committed REPL line to stdout's current width (U.12), id/status-first. */
+function fitOut(line) {
+    return fit(line, resolveColumns(process.stdout), theme.glyph.ellipsis);
+}
 const PROMPT = `${theme.accent("cruxy")} ${theme.muted(theme.glyph.caret)} `;
 /**
  * The REPL's slash commands — the autocomplete candidate set (U.7). Keep in
@@ -185,7 +189,9 @@ function handleJobsList(session) {
             ? theme.muted(` — needs approval: ${j.pendingApproval}`)
             : "";
         const err = j.error ? theme.muted(` (${j.error})`) : "";
-        logger.print(`${theme.strong(j.id)}  ${status}  ${j.label}${pending}${err}`);
+        // Fit id-first so the job id + status always survive; the label/notes tail
+        // truncates with an honest ellipsis at narrow width (U.12).
+        logger.print(fitOut(`${theme.strong(j.id)}  ${status}  ${j.label}${pending}${err}`));
     }
 }
 /** Print one job's log (`/logs <id>`). */
@@ -207,7 +213,7 @@ function handleJobLogs(input, session) {
         }
         for (const line of log.lines) {
             const text = line.stream === "err" ? theme.danger(line.text) : line.text;
-            logger.print(text);
+            logger.print(fitOut(text));
         }
         logger.print(theme.muted(`(${log.status})`));
     }

package/dist/components/frame.d.ts

@@ -1,6 +1,7 @@
+import { stripAnsi } from "../render/layout.js";
 import type { RenderCapabilities } from "../render/index.js";
-/** The visible text of a possibly-styled row. */
-export declare function stripAnsi(text: string): string;
+/** The visible text of a possibly-styled row (re-exported from the U.12 home). */
+export { stripAnsi };
 /**
  * The transient multi-line region interactive components draw into (U.7) —
  * the multi-row analog of the TTY renderer's single managed status line, with
@@ -12,6 +13,8 @@ export declare function stripAnsi(text: string): string;
  *   soft-wrap; wrapped rows would break erasure and leave artifacts.
  * - `clear()` removes the frame entirely — after a component resolves, the
  *   screen holds zero leftover bytes from the interaction.
+ * - On resize (U.12) the frame reflows its current rows in place at the new
+ *   width; committed output above is untouched. `clear()` also unsubscribes.
  *
  * Requires cursor control (`caps.cursor`); components guard on that before
  * constructing one.
@@ -19,7 +22,7 @@ export declare function stripAnsi(text: string): string;
 export interface Frame {
     /** Repaint the frame with these rows (erases the previous paint first). */
     render(lines: string[]): void;
-    /** Erase the frame completely. Idempotent. */
+    /** Erase the frame completely and release the resize subscription. Idempotent. */
     clear(): void;
 }
 export declare function createFrame(write: (text: string) => void, caps: RenderCapabilities): Frame;

package/dist/components/frame.js

@@ -1,32 +1,22 @@
+import { fit, stripAnsi } from "../render/layout.js";
 import { resolveTheme } from "../theme/index.js";
 /** Erase the current line and return the cursor to column 0 (same as U.2). */
 const CLEAR_LINE = "\r\x1b[2K";
 /** Move the cursor up one row. */
 const CURSOR_UP = "\x1b[1A";
-/** SGR escape sequences (the only ANSI the components emit — via picocolors). */
-// eslint-disable-next-line no-control-regex
-const SGR = /\x1b\[[0-9;]*m/g;
-/** The visible text of a possibly-styled row. */
-export function stripAnsi(text) {
-    return text.replace(SGR, "");
-}
+/** The visible text of a possibly-styled row (re-exported from the U.12 home). */
+export { stripAnsi };
 export function createFrame(write, caps) {
     let drawn = 0;
+    let lastLines = [];
     const ellipsis = resolveTheme(caps).glyph.ellipsis;
     /**
      * Truncate to width-1 (cursor rests after the last cell; a full-width row
      * would auto-wrap on some terminals). Width is measured on VISIBLE
-     * characters — rows may carry ANSI color. A row that fits passes through
-     * styled; an overflowing row is truncated on its stripped text (style is
-     * dropped rather than risking a cut escape sequence).
+     * characters (U.12 {@link fit}) — rows may carry ANSI color; a row that fits
+     * passes through styled, an overflowing row is truncated on its visible text.
      */
-    const fit = (line) => {
-        const room = Math.max(1, caps.width - 1);
-        const plain = stripAnsi(line);
-        if (plain.length <= room)
-            return line;
-        return plain.slice(0, room - 1) + ellipsis;
-    };
+    const fitRow = (line) => fit(line, Math.max(1, caps.width - 1), ellipsis);
     const erase = () => {
         if (drawn === 0)
             return;
@@ -38,14 +28,22 @@ export function createFrame(write, caps) {
         write(out);
         drawn = 0;
     };
+    const paint = (lines) => {
+        erase();
+        lastLines = lines;
+        if (lines.length === 0)
+            return;
+        write(lines.map(fitRow).join("\n"));
+        drawn = lines.length;
+    };
+    // Reflow the live frame at the new width; committed output above is immutable.
+    const unsubscribe = caps.onResize?.(() => paint(lastLines)) ?? null;
     return {
-        render(lines) {
+        render: paint,
+        clear() {
             erase();
-            if (lines.length === 0)
-                return;
-            write(lines.map(fit).join("\n"));
-            drawn = lines.length;
+            lastLines = [];
+            unsubscribe?.();
         },
-        clear: erase,
     };
 }

package/dist/components/fuzzy.js

@@ -1,3 +1,4 @@
+import { fitMiddle } from "../render/layout.js";
 import { resolveTheme } from "../theme/index.js";
 import { createFrame } from "./frame.js";
 import { defaultComponentIO, resolveNonInteractive, } from "./input.js";
@@ -117,7 +118,10 @@ export async function fuzzyFind(items, opts, io = defaultComponentIO()) {
             for (const [i, row] of visible.entries()) {
                 const selected = top + i === cursor;
                 const marker = selected ? t.accent(g.pointer) : " ";
-                const label = highlightMatch(row.label, row.match.positions, t);
+                // Middle-truncate so a long hit keeps its basename at narrow width
+                // (U.12); the match highlight survives when the label fits and is
+                // dropped (plain text) only when it must truncate — identity over decor.
+                const label = fitMiddle(highlightMatch(row.label, row.match.positions, t), Math.max(1, io.caps.width - 2), g.ellipsis);
                 lines.push(`${marker} ${selected ? label : t.muted(label)}`);
             }
             const hidden = ranked.length - visible.length;

package/dist/components/select.js

@@ -1,3 +1,4 @@
+import { fitMiddle } from "../render/layout.js";
 import { resolveTheme } from "../theme/index.js";
 import { createFrame } from "./frame.js";
 import { defaultComponentIO, resolveNonInteractive, } from "./input.js";
@@ -29,7 +30,9 @@ export async function selectList(items, opts = {}, io = defaultComponentIO()) {
         for (const [i, item] of visible.entries()) {
             const selected = top + i === cursor;
             const marker = selected ? t.accent(g.pointer) : " ";
-            const label = toLabel(item);
+            // Middle-truncate the label so a long path keeps its basename (identity)
+            // at narrow width (U.12); reserve the marker + space.
+            const label = fitMiddle(toLabel(item), Math.max(1, io.caps.width - 2), g.ellipsis);
             lines.push(`${marker} ${selected ? label : t.muted(label)}`);
         }
         const hidden = items.length - visible.length;

package/dist/render/capabilities.d.ts

@@ -1,4 +1,15 @@
 import type { RenderCapabilities, RenderStream } from "./types.js";
+/** Fallback width when the terminal reports none (non-TTY, pipe, unknown). */
+export declare const DEFAULT_COLUMNS = 80;
+/**
+ * Resolve the terminal width (U.12) — the single rule behind
+ * {@link RenderCapabilities.width} and every resize recompute. `COLUMNS` wins
+ * when set (honored so `COLUMNS=100 cruxy …` and CI overrides work), then the
+ * stream's own `columns`, then {@link DEFAULT_COLUMNS}. Never returns a
+ * non-positive width — an unknown terminal degrades to a sensible default, it
+ * does not crash a width calculation with 0.
+ */
+export declare function resolveColumns(stream?: RenderStream, env?: NodeJS.ProcessEnv): number;
 /**
  * Reduced-motion (U.11) — the ecosystem `NO_MOTION` signal, the explicit cruxy
  * knob `CRUXY_REDUCED_MOTION`, and `CRUXY_NO_SPINNER` kept as an alias flowing

package/dist/render/capabilities.js

@@ -4,6 +4,24 @@ import { detectScreenReader, detectUnicode } from "../theme/index.js";
 function isSet(value) {
     return value !== undefined && value !== "";
 }
+/** Fallback width when the terminal reports none (non-TTY, pipe, unknown). */
+export const DEFAULT_COLUMNS = 80;
+/**
+ * Resolve the terminal width (U.12) — the single rule behind
+ * {@link RenderCapabilities.width} and every resize recompute. `COLUMNS` wins
+ * when set (honored so `COLUMNS=100 cruxy …` and CI overrides work), then the
+ * stream's own `columns`, then {@link DEFAULT_COLUMNS}. Never returns a
+ * non-positive width — an unknown terminal degrades to a sensible default, it
+ * does not crash a width calculation with 0.
+ */
+export function resolveColumns(stream = process.stdout, env = process.env) {
+    const fromEnv = env.COLUMNS === undefined ? NaN : Number.parseInt(env.COLUMNS, 10);
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    if (typeof stream.columns === "number" && stream.columns > 0)
+        return stream.columns;
+    return DEFAULT_COLUMNS;
+}
 /**
  * Reduced-motion (U.11) — the ecosystem `NO_MOTION` signal, the explicit cruxy
  * knob `CRUXY_REDUCED_MOTION`, and `CRUXY_NO_SPINNER` kept as an alias flowing
@@ -44,8 +62,6 @@ export function detectCapabilities(stream = process.stdout, env = process.env) {
         // Unicode glyph safety (U.1) — independent of color. dumb / CRUXY_ASCII →
         // ASCII glyphs; everything else (incl. pipes) keeps unicode.
         unicode: detectUnicode(env),
-        width: typeof stream.columns === "number" && stream.columns > 0
-            ? stream.columns
-            : 80,
+        width: resolveColumns(stream, env),
     };
 }

package/dist/render/diff.d.ts

@@ -15,4 +15,4 @@ export declare const PREVIEW_MAX_LINES = 40;
  * patches, a create/overwrite listing for writes, the publish plan for PRs.
  * Long previews collapse past {@link PREVIEW_MAX_LINES}.
  */
-export declare function renderActionPreview(preview: ActionPreview | undefined, c: Theme): string;
+export declare function renderActionPreview(preview: ActionPreview | undefined, c: Theme, width?: number): string;

package/dist/render/diff.js

@@ -1,3 +1,4 @@
+import { fit, fitMiddle } from "./layout.js";
 /**
  * The one diff/action-preview renderer (U.2). The approval prompt, PR preview,
  * and the streaming render path all draw diffs through here — there is no
@@ -13,20 +14,28 @@ function diffLines(oldStr, newStr, c) {
     const added = newStr.split("\n").map((l) => c.success(`+ ${l}`));
     return [...removed, ...added];
 }
-function renderPatchFiles(files, c) {
+/**
+ * Middle-truncate a file path so its basename (the strongest identifier)
+ * survives narrow width (U.12). `width` defaults to `Infinity`, so callers that
+ * don't thread width get the exact pre-U.12 bytes.
+ */
+function fitPath(path, c, width) {
+    return fitMiddle(path, Math.max(1, width - 10), c.glyph.ellipsis);
+}
+function renderPatchFiles(files, c, width = Infinity) {
     const out = [];
     for (const file of files) {
         if (file.op === "delete") {
-            out.push(c.danger(`delete ${file.path}`));
+            out.push(c.danger(`delete ${fitPath(file.path, c, width)}`));
         }
         else if (file.op === "create") {
-            out.push(c.success(`create ${file.path}`));
+            out.push(c.success(`create ${fitPath(file.path, c, width)}`));
             out.push(...file.lines.map((l) => c.success(`+ ${l}`)));
             if (file.omittedLines > 0)
                 out.push(c.muted(`  ...${file.omittedLines} more lines`));
         }
         else {
-            out.push(c.warning(`update ${file.path}`));
+            out.push(c.warning(`update ${fitPath(file.path, c, width)}`));
             for (const hunk of file.hunks)
                 out.push(...diffLines(hunk.oldStr, hunk.newStr, c));
         }
@@ -116,7 +125,7 @@ function bodyLines(body) {
  * patches, a create/overwrite listing for writes, the publish plan for PRs.
  * Long previews collapse past {@link PREVIEW_MAX_LINES}.
  */
-export function renderActionPreview(preview, c) {
+export function renderActionPreview(preview, c, width = Infinity) {
     if (!preview)
         return "";
     let lines;
@@ -124,7 +133,7 @@ export function renderActionPreview(preview, c) {
         lines = diffLines(preview.oldStr, preview.newStr, c);
     }
     else if (preview.type === "patch") {
-        lines = renderPatchFiles(preview.files, c);
+        lines = renderPatchFiles(preview.files, c, width);
     }
     else if (preview.type === "pr") {
         lines = renderPrPreview(preview, c);
@@ -151,5 +160,12 @@ export function renderActionPreview(preview, c) {
             c.muted(`...${hidden} more`),
         ];
     }
-    return lines.map((l) => `  ${l}`).join("\n");
+    // Horizontal fit at the single choke point (U.12): every content line is
+    // truncated to the width available inside the 2-space indent, so no line ever
+    // soft-wraps. `fit` truncates from the RIGHT, so a diff line keeps its leading
+    // `+`/`-` sign and a labeled line keeps its `create`/`update`/`delete` verb —
+    // the meaning at line-start is never the part that's dropped. Default width
+    // Infinity → no-op, so non-threaded callers get the pre-U.12 bytes.
+    const room = Math.max(1, width - 2);
+    return lines.map((l) => `  ${fit(l, room, c.glyph.ellipsis)}`).join("\n");
 }

package/dist/render/index.d.ts

@@ -1,7 +1,9 @@
 import type { RenderStream, StreamRenderer } from "./types.js";
 export type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, TokenUsage, ToolLifecycleEvent, } from "./types.js";
-export { detectCapabilities, detectReducedMotion } from "./capabilities.js";
-export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
+export { detectCapabilities, detectReducedMotion, resolveColumns, DEFAULT_COLUMNS, } from "./capabilities.js";
+export { attachResize, processResizeSignal, type ResizeSignal, } from "./resize.js";
+export { fit, fitMiddle, reflow, stripAnsi, visibleWidth, kvStack, MIN_VALUE_COLS, type KvRow, } from "./layout.js";
+export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, fitStatusLine, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
 export { renderActionPreview, PREVIEW_MAX_LINES } from "./diff.js";
 export { createStreamHighlighter, defaultLineHighlighter, type HighlightCarry, type LineHighlighter, type StreamHighlighter, } from "./highlight.js";
 export { PlainRenderer } from "./plain-renderer.js";

package/dist/render/index.js

@@ -1,9 +1,12 @@
 import { detectCapabilities } from "./capabilities.js";
 import { PlainRenderer } from "./plain-renderer.js";
+import { attachResize } from "./resize.js";
 import { ScreenReaderRenderer } from "./screen-reader-renderer.js";
 import { TtyRenderer } from "./tty-renderer.js";
-export { detectCapabilities, detectReducedMotion } from "./capabilities.js";
-export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
+export { detectCapabilities, detectReducedMotion, resolveColumns, DEFAULT_COLUMNS, } from "./capabilities.js";
+export { attachResize, processResizeSignal, } from "./resize.js";
+export { fit, fitMiddle, reflow, stripAnsi, visibleWidth, kvStack, MIN_VALUE_COLS, } from "./layout.js";
+export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, fitStatusLine, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
 export { renderActionPreview, PREVIEW_MAX_LINES } from "./diff.js";
 export { createStreamHighlighter, defaultLineHighlighter, } from "./highlight.js";
 export { PlainRenderer } from "./plain-renderer.js";
@@ -20,6 +23,9 @@ export { TtyRenderer } from "./tty-renderer.js";
  */
 export function createRenderer(out = process.stdout, err = process.stderr, env = process.env) {
     const caps = detectCapabilities(out, env);
+    // Wire resize reactivity onto the one caps object before any surface reads
+    // its width (U.12). A no-op for non-TTY streams; the live region subscribes.
+    attachResize(caps, out, env);
     if (caps.screenReader)
         return new ScreenReaderRenderer(caps, out, err);
     return caps.cursor

package/dist/render/layout.d.ts

@@ -0,0 +1,59 @@
+import type { Theme } from "../theme/index.js";
+/** The visible text of a possibly-styled string (SGR removed). */
+export declare function stripAnsi(text: string): string;
+/**
+ * Visible width in code points — the number a terminal cell count approximates.
+ * Counts by code point (via spread) so a surrogate-pair glyph is 1, not 2, and
+ * is never split. Wide (CJK/emoji) cells are counted as 1; full display-width
+ * accounting is deliberately out of scope (U.12), but code-point counting is
+ * already strictly more correct than the pre-U.12 `.length`.
+ */
+export declare function visibleWidth(text: string): number;
+/**
+ * Truncate `text` to at most `width` visible columns, appending an honest
+ * ellipsis when anything was dropped. Text that already fits is returned
+ * UNCHANGED (style preserved). A truncated string is returned as plain text:
+ * dropping the style on the cut tail is the safe choice — re-styling a slice
+ * risks emitting a half of an escape pair.
+ *
+ * `width < 1` yields "". When `width` is smaller than the ellipsis itself
+ * (very-narrow), we show that many content characters rather than only dots —
+ * a single legible char beats a clipped "…".
+ */
+export declare function fit(text: string, width: number, ellipsis?: string): string;
+/**
+ * Truncate the MIDDLE, preserving the head and tail. For a path or a search
+ * hit, the tail (basename, `:line`) carries as much identity as the head
+ * (root) — a right-truncation would hide the very thing that names it. Yields
+ * `src/very/deep/…/Component.tsx`. Falls back to {@link fit} when there is no
+ * room for both sides plus the ellipsis. Returns plain text when it truncates.
+ */
+export declare function fitMiddle(text: string, width: number, ellipsis?: string): string;
+/**
+ * Word-wrap `text` to `width` visible columns, returning the wrapped lines.
+ * Wraps at spaces; a single token longer than `width` is hard-broken (its style
+ * is dropped on the break). Existing newlines are preserved as paragraph
+ * breaks. Use this — not {@link fit} — when meaning must survive in full (an
+ * approval command you must see whole), trading vertical space for completeness.
+ */
+export declare function reflow(text: string, width: number): string[];
+/** A key/value pair for {@link kvStack}. */
+export interface KvRow {
+    key: string;
+    value: string;
+}
+/**
+ * Minimum value columns an aligned two-column table needs before it collapses
+ * to a stack. Below this, the value column is too cramped to read, so stacking
+ * (key on its own line, value reflowed beneath) is the honest presentation.
+ */
+export declare const MIN_VALUE_COLS = 16;
+/**
+ * The table→stack collapser (U.12). At a width that affords the widest key plus
+ * {@link MIN_VALUE_COLS}, render aligned `key  value` rows (values truncated to
+ * the remaining columns). Too narrow for that, STACK each pair — a bold key
+ * line, then the value reflowed and indented — so a table never soft-wraps into
+ * a misaligned mess and never hides a value. One column budgeter for every kv
+ * caller.
+ */
+export declare function kvStack(rows: KvRow[], width: number, theme: Theme): string[];

package/dist/render/layout.js

@@ -0,0 +1,158 @@
+/**
+ * Width-aware layout (U.12): the ANSI-aware truncate/reflow/collapse helpers
+ * every rendered surface uses to fit content to `RenderCapabilities.width`.
+ * Pure string → string, like diff.ts / state.ts — no terminal, no width source
+ * of its own (callers pass the one `caps.width`), so each helper is directly
+ * testable.
+ *
+ * The one rule these enforce: width is measured on VISIBLE characters, not
+ * bytes. A colored 10-visible-char string is 10 wide even though its byte
+ * length is larger (SGR escapes) — truncating on `.length` would cut early and
+ * could sever an escape sequence mid-way, leaving torn ANSI on screen. So we
+ * strip SGR for the measurement and slice on CODE POINTS (never UTF-16 units),
+ * which also prevents splitting an astral glyph into two broken halves.
+ */
+/** SGR escape sequences (the only ANSI our surfaces emit — via picocolors). */
+// eslint-disable-next-line no-control-regex
+const SGR = /\x1b\[[0-9;]*m/g;
+/** The visible text of a possibly-styled string (SGR removed). */
+export function stripAnsi(text) {
+    return text.replace(SGR, "");
+}
+/**
+ * Visible width in code points — the number a terminal cell count approximates.
+ * Counts by code point (via spread) so a surrogate-pair glyph is 1, not 2, and
+ * is never split. Wide (CJK/emoji) cells are counted as 1; full display-width
+ * accounting is deliberately out of scope (U.12), but code-point counting is
+ * already strictly more correct than the pre-U.12 `.length`.
+ */
+export function visibleWidth(text) {
+    return [...stripAnsi(text)].length;
+}
+/**
+ * Truncate `text` to at most `width` visible columns, appending an honest
+ * ellipsis when anything was dropped. Text that already fits is returned
+ * UNCHANGED (style preserved). A truncated string is returned as plain text:
+ * dropping the style on the cut tail is the safe choice — re-styling a slice
+ * risks emitting a half of an escape pair.
+ *
+ * `width < 1` yields "". When `width` is smaller than the ellipsis itself
+ * (very-narrow), we show that many content characters rather than only dots —
+ * a single legible char beats a clipped "…".
+ */
+export function fit(text, width, ellipsis = "…") {
+    if (width < 1)
+        return "";
+    const chars = [...stripAnsi(text)];
+    if (chars.length <= width)
+        return text;
+    const ell = [...ellipsis].length;
+    if (width <= ell)
+        return chars.slice(0, width).join("");
+    return chars.slice(0, width - ell).join("") + ellipsis;
+}
+/**
+ * Truncate the MIDDLE, preserving the head and tail. For a path or a search
+ * hit, the tail (basename, `:line`) carries as much identity as the head
+ * (root) — a right-truncation would hide the very thing that names it. Yields
+ * `src/very/deep/…/Component.tsx`. Falls back to {@link fit} when there is no
+ * room for both sides plus the ellipsis. Returns plain text when it truncates.
+ */
+export function fitMiddle(text, width, ellipsis = "…") {
+    if (width < 1)
+        return "";
+    const chars = [...stripAnsi(text)];
+    if (chars.length <= width)
+        return text;
+    const ell = [...ellipsis].length;
+    if (width <= ell + 1)
+        return fit(text, width, ellipsis);
+    const budget = width - ell;
+    const head = Math.ceil(budget / 2);
+    const tail = budget - head;
+    const start = chars.slice(0, head).join("");
+    const end = tail > 0 ? chars.slice(chars.length - tail).join("") : "";
+    return start + ellipsis + end;
+}
+/** Break one over-long token into `width`-wide code-point chunks (plain text). */
+function hardBreak(word, width) {
+    const chars = [...stripAnsi(word)];
+    const chunks = [];
+    for (let i = 0; i < chars.length; i += width) {
+        chunks.push(chars.slice(i, i + width).join(""));
+    }
+    return chunks;
+}
+/**
+ * Word-wrap `text` to `width` visible columns, returning the wrapped lines.
+ * Wraps at spaces; a single token longer than `width` is hard-broken (its style
+ * is dropped on the break). Existing newlines are preserved as paragraph
+ * breaks. Use this — not {@link fit} — when meaning must survive in full (an
+ * approval command you must see whole), trading vertical space for completeness.
+ */
+export function reflow(text, width) {
+    if (width < 1)
+        return [text];
+    const out = [];
+    for (const para of text.split("\n")) {
+        if (para === "") {
+            out.push("");
+            continue;
+        }
+        let line = "";
+        for (const word of para.split(" ")) {
+            const candidate = line === "" ? word : `${line} ${word}`;
+            if (visibleWidth(candidate) <= width) {
+                line = candidate;
+                continue;
+            }
+            if (line !== "") {
+                out.push(line);
+                line = "";
+            }
+            if (visibleWidth(word) <= width) {
+                line = word;
+            }
+            else {
+                const chunks = hardBreak(word, width);
+                for (let i = 0; i < chunks.length - 1; i++)
+                    out.push(chunks[i]);
+                line = chunks[chunks.length - 1] ?? "";
+            }
+        }
+        out.push(line);
+    }
+    return out;
+}
+/**
+ * Minimum value columns an aligned two-column table needs before it collapses
+ * to a stack. Below this, the value column is too cramped to read, so stacking
+ * (key on its own line, value reflowed beneath) is the honest presentation.
+ */
+export const MIN_VALUE_COLS = 16;
+/**
+ * The table→stack collapser (U.12). At a width that affords the widest key plus
+ * {@link MIN_VALUE_COLS}, render aligned `key  value` rows (values truncated to
+ * the remaining columns). Too narrow for that, STACK each pair — a bold key
+ * line, then the value reflowed and indented — so a table never soft-wraps into
+ * a misaligned mess and never hides a value. One column budgeter for every kv
+ * caller.
+ */
+export function kvStack(rows, width, theme) {
+    if (rows.length === 0)
+        return [];
+    const glyph = theme.glyph.ellipsis;
+    const keyWidth = Math.max(...rows.map((r) => visibleWidth(r.key)));
+    const valueRoom = width - keyWidth - 2;
+    if (valueRoom >= MIN_VALUE_COLS) {
+        return rows.map((r) => theme.kv(r.key, fit(r.value, valueRoom, glyph), keyWidth));
+    }
+    const out = [];
+    for (const r of rows) {
+        out.push(theme.strong(r.key));
+        for (const line of reflow(r.value, Math.max(1, width - 2))) {
+            out.push(`  ${line}`);
+        }
+    }
+    return out;
+}

package/dist/render/resize.d.ts

@@ -0,0 +1,36 @@
+import type { RenderCapabilities, RenderStream } from "./types.js";
+/**
+ * Resize reactivity (U.12). Terminal width lives in exactly one place —
+ * {@link RenderCapabilities.width} — and this module is what keeps it current:
+ * it listens for the OS resize signal, recomputes the width through the same
+ * {@link resolveColumns} rule that seeded it, updates `caps.width` IN PLACE, and
+ * pushes the new width to subscribers (the live region / transient frames).
+ *
+ * Committed output is never re-rendered from here — only surfaces that own a
+ * redrawable region subscribe. Everything else simply reads the now-current
+ * `caps.width` the next time it emits.
+ *
+ * The OS signal is injectable ({@link ResizeSignal}) so tests drive resize
+ * deterministically without a real terminal or a real SIGWINCH.
+ */
+/**
+ * The OS resize signal, abstracted for testability. `on` registers a callback
+ * fired on each terminal resize and returns an unsubscribe function.
+ */
+export interface ResizeSignal {
+    on(listener: () => void): () => void;
+}
+/** The real signal: Node emits `SIGWINCH` on the process when a TTY resizes. */
+export declare const processResizeSignal: ResizeSignal;
+/**
+ * Wire resize reactivity onto `caps`: install {@link RenderCapabilities.onResize}
+ * and start listening for terminal resizes. One OS listener is shared across all
+ * subscribers and is removed once the last one unsubscribes (and re-added if a
+ * new subscriber arrives), so nothing is leaked and the process is never held
+ * open by a stray handler.
+ *
+ * A no-op for streams that cannot resize (non-TTY / no `columns`): `onResize`
+ * stays undefined and surfaces fall back to the static width. Idempotent —
+ * calling twice on the same caps keeps the first wiring.
+ */
+export declare function attachResize(caps: RenderCapabilities, stream?: RenderStream, env?: NodeJS.ProcessEnv, signal?: ResizeSignal): void;

package/dist/render/resize.js

@@ -0,0 +1,45 @@
+import { resolveColumns } from "./capabilities.js";
+/** The real signal: Node emits `SIGWINCH` on the process when a TTY resizes. */
+export const processResizeSignal = {
+    on(listener) {
+        process.on("SIGWINCH", listener);
+        return () => void process.off("SIGWINCH", listener);
+    },
+};
+/**
+ * Wire resize reactivity onto `caps`: install {@link RenderCapabilities.onResize}
+ * and start listening for terminal resizes. One OS listener is shared across all
+ * subscribers and is removed once the last one unsubscribes (and re-added if a
+ * new subscriber arrives), so nothing is leaked and the process is never held
+ * open by a stray handler.
+ *
+ * A no-op for streams that cannot resize (non-TTY / no `columns`): `onResize`
+ * stays undefined and surfaces fall back to the static width. Idempotent —
+ * calling twice on the same caps keeps the first wiring.
+ */
+export function attachResize(caps, stream = process.stdout, env = process.env, signal = processResizeSignal) {
+    if (!stream.isTTY || caps.onResize)
+        return;
+    const listeners = new Set();
+    let off = null;
+    const onSignal = () => {
+        const next = resolveColumns(stream, env);
+        if (next === caps.width)
+            return;
+        caps.width = next; // the single source stays current — no second copy.
+        for (const l of [...listeners])
+            l(next);
+    };
+    caps.onResize = (listener) => {
+        listeners.add(listener);
+        if (off === null)
+            off = signal.on(onSignal);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0 && off !== null) {
+                off();
+                off = null;
+            }
+        };
+    };
+}

package/dist/render/state.d.ts

@@ -34,3 +34,16 @@ export declare function phaseIdentity(phase: RenderPhase | null): string;
  * when they can keep it ticking honestly (no timer → no frozen number).
  */
 export declare function composeStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs?: number, glyph?: ThemeGlyphs): string;
+/**
+ * The width-aware live line (U.12): {@link composeStatusLine} with honest
+ * degradation tiers so the status line never soft-wraps and never loses its
+ * essential meaning — *what is happening*. Priority is phase (the action) >
+ * the `[i/n] title` progress prefix (context) > the elapsed clock (decor), so
+ * as width shrinks we shed decor first and identity last:
+ *
+ * - wide: `[2/5] title · read_file src/x.ts… (12s)`
+ * - medium: drop the elapsed clock
+ * - narrow: drop the `[i/n] title` prefix, keep the phase
+ * - very-narrow: {@link fit} the phase text with an honest ellipsis
+ */
+export declare function fitStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs: number | undefined, glyph: ThemeGlyphs, width: number): string;

package/dist/render/state.js

@@ -1,4 +1,5 @@
 import { UNICODE_GLYPHS } from "../theme/index.js";
+import { fit, visibleWidth } from "./layout.js";
 /**
  * The U.4 state→text mapping: pure data → string, like plan/render.ts and
  * diff.ts, so both renderers (and tests) share one composition with no
@@ -90,3 +91,40 @@ export function composeStatusLine(progress, phase, elapsedMs, glyph = UNICODE_GL
     }
     return line;
 }
+/**
+ * The width-aware live line (U.12): {@link composeStatusLine} with honest
+ * degradation tiers so the status line never soft-wraps and never loses its
+ * essential meaning — *what is happening*. Priority is phase (the action) >
+ * the `[i/n] title` progress prefix (context) > the elapsed clock (decor), so
+ * as width shrinks we shed decor first and identity last:
+ *
+ * - wide: `[2/5] title · read_file src/x.ts… (12s)`
+ * - medium: drop the elapsed clock
+ * - narrow: drop the `[i/n] title` prefix, keep the phase
+ * - very-narrow: {@link fit} the phase text with an honest ellipsis
+ */
+export function fitStatusLine(progress, phase, elapsedMs, glyph, width) {
+    const sep = ` ${glyph.sep} `;
+    const phaseText = phase ? describePhase(phase, glyph) : "";
+    const prefix = progress
+        ? `[${progress.step}/${progress.of}] ${progress.title}`
+        : "";
+    const elapsed = elapsedMs !== undefined && elapsedMs >= ELAPSED_AFTER_MS
+        ? ` (${formatElapsed(elapsedMs)})`
+        : "";
+    const join = (parts) => parts.filter((p) => p !== "").join(sep);
+    // The identity that must survive to the last: the phase, or the progress
+    // prefix when there is no phase (between-turns step context).
+    const essential = phaseText !== "" ? phaseText : prefix;
+    const candidates = [
+        join([prefix, phaseText]) + elapsed, // full
+        join([prefix, phaseText]), // drop elapsed
+        phaseText + elapsed, // drop progress prefix
+        essential, // essential only
+    ];
+    for (const c of candidates) {
+        if (c !== "" && visibleWidth(c) <= width)
+            return c;
+    }
+    return fit(essential, width, glyph.ellipsis);
+}

package/dist/render/tty-renderer.d.ts

@@ -48,7 +48,15 @@ export declare class TtyRenderer implements StreamRenderer {
     private timer;
     private frame;
     private closed;
+    /** Unsubscribe from the resize signal (U.12); null when the stream can't resize. */
+    private unsubscribeResize;
     constructor(caps: RenderCapabilities, out: RenderStream);
+    /**
+     * Redraw the live line at the current `caps.width` after a resize. A no-op
+     * when nothing is drawn (so a resize between turns writes zero bytes) — the
+     * next state transition will draw at the new width anyway.
+     */
+    private reflowLive;
     private newPrinter;
     /** Append committed content, erasing the status line first if one is live. */
     private commit;

package/dist/render/tty-renderer.js

@@ -2,7 +2,8 @@ import { resolveTheme } from "../theme/index.js";
 import { createStreamPrinter } from "../cli/stream-print.js";
 import { renderActionPreview } from "./diff.js";
 import { createStreamHighlighter, } from "./highlight.js";
-import { composeStatusLine, ELAPSED_AFTER_MS, formatElapsed, phaseIdentity, } from "./state.js";
+import { fit } from "./layout.js";
+import { ELAPSED_AFTER_MS, fitStatusLine, formatElapsed, phaseIdentity, } from "./state.js";
 /** Erase the current line and return the cursor to column 0. */
 const CLEAR_LINE = "\r\x1b[2K";
 const SPINNER_INTERVAL_MS = 100;
@@ -53,12 +54,32 @@ export class TtyRenderer {
     timer = null;
     frame = 0;
     closed = false;
+    /** Unsubscribe from the resize signal (U.12); null when the stream can't resize. */
+    unsubscribeResize = null;
     constructor(caps, out) {
         this.caps = caps;
         this.out = out;
         this.theme = resolveTheme(caps);
         this.highlighter = createStreamHighlighter(this.theme);
         this.print = this.newPrinter();
+        // Resize reactivity (U.12): only the live line reflows at the new width —
+        // committed rows above are immutable and never rewritten.
+        this.unsubscribeResize = caps.onResize?.(() => this.reflowLive()) ?? null;
+    }
+    /**
+     * Redraw the live line at the current `caps.width` after a resize. A no-op
+     * when nothing is drawn (so a resize between turns writes zero bytes) — the
+     * next state transition will draw at the new width anyway.
+     */
+    reflowLive() {
+        if (this.closed || !this.lineVisible)
+            return;
+        const line = this.currentLine();
+        if (line === null) {
+            this.hideLine();
+            return;
+        }
+        this.drawLine(line);
     }
     newPrinter() {
         return createStreamPrinter((text) => {
@@ -112,7 +133,10 @@ export class TtyRenderer {
         const elapsed = this.phase !== null && this.caps.spinner
             ? Date.now() - this.phaseStartedAt
             : undefined;
-        return composeStatusLine(this.progressState, this.phase, elapsed, this.theme.glyph);
+        // Reserve the glyph + space (2 cols): the composed line is degraded and
+        // fitted to the remainder so it can never soft-wrap (U.12).
+        const room = Math.max(1, this.caps.width - 2);
+        return fitStatusLine(this.progressState, this.phase, elapsed, this.theme.glyph, room);
     }
     /** Redraw the live line from current state, or hide it when there is none. */
     refresh() {
@@ -139,11 +163,10 @@ export class TtyRenderer {
         const glyph = this.caps.spinner
             ? frames[this.frame % frames.length]
             : this.theme.glyph.spinnerStatic;
-        // Reserve glyph + space; truncate so the live line can never soft-wrap.
+        // Reserve glyph + space; ANSI-aware fit so the live line can never
+        // soft-wrap (currentLine already fits — this is defense in depth) (U.12).
         const room = Math.max(1, this.caps.width - 2);
-        const line = text.length > room
-            ? text.slice(0, Math.max(0, room - 1)) + this.theme.glyph.ellipsis
-            : text;
+        const line = fit(text, room, this.theme.glyph.ellipsis);
         this.out.write(`${CLEAR_LINE}${this.theme.accent(glyph)} ${this.theme.muted(line)}`);
     }
     beginTurn() {
@@ -168,16 +191,16 @@ export class TtyRenderer {
     note(text) {
         if (this.closed)
             return;
-        const room = Math.max(1, this.caps.width);
-        const line = text.length > room
-            ? text.slice(0, room - 1) + this.theme.glyph.ellipsis
-            : text;
+        // ANSI-aware fit (U.12): a note may carry color (subagent trail marks), so
+        // width must be measured on visible chars, not bytes, or it truncates early
+        // and can sever an escape sequence.
+        const line = fit(text, Math.max(1, this.caps.width), this.theme.glyph.ellipsis);
         this.commit(this.theme.muted(line) + "\n");
     }
     preview(preview) {
         if (this.closed)
             return;
-        const block = renderActionPreview(preview, this.theme);
+        const block = renderActionPreview(preview, this.theme, this.caps.width);
         if (block)
             this.commit(block + "\n");
     }
@@ -274,6 +297,8 @@ export class TtyRenderer {
         if (this.closed)
             return;
         this.endTurn();
+        this.unsubscribeResize?.();
+        this.unsubscribeResize = null;
         this.closed = true;
     }
 }

package/dist/render/types.d.ts

@@ -39,8 +39,22 @@ export interface RenderCapabilities {
     /** Unicode glyphs are safe (U.1) — false under `TERM=dumb` / `CRUXY_ASCII`;
      * independent of `color`. Drives the theme's glyph table, not its stylers. */
     unicode: boolean;
-    /** Terminal columns; 80 when unknown (non-TTY). */
+    /**
+     * Terminal columns (U.12) — the ONE width source every surface reads; 80 when
+     * unknown (non-TTY / no `columns`). Honors `COLUMNS` when set. Mutated in
+     * place on resize (see {@link onResize}), so a surface reading it after a
+     * SIGWINCH sees the new width without re-probing anything.
+     */
     width: number;
+    /**
+     * Subscribe to width changes (U.12): the SIGWINCH push signal for the live
+     * region / transient frames to reflow at the new width. The listener fires
+     * with the new width AFTER {@link width} has been updated; the returned
+     * function unsubscribes. Absent when the stream cannot resize (non-TTY / no
+     * `columns`) — those surfaces just read the static {@link width}. Committed
+     * output is never re-rendered from here; only live surfaces subscribe.
+     */
+    onResize?(listener: (width: number) => void): () => void;
 }
 /** Accumulated token usage the loop already tracks (U.4) — never fabricated. */
 export interface TokenUsage {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {