@cruxy/cli 0.11.0 → 0.12.0

package/dist/render/highlight.js

@@ -7,7 +7,7 @@ const FENCE_PLAUSIBLE = /^(?:`{1,2}|`{3,}[\w+#.-]*\s*)$/;
  * Create the per-segment streaming highlighter. `highlightLine` is injectable
  * for tests (e.g. to prove a throwing tokenizer degrades to plain text).
  */
-export function createStreamHighlighter(c, highlightLine = defaultLineHighlighter(c)) {
+export function createStreamHighlighter(theme, highlightLine = defaultLineHighlighter(theme)) {
     let mode = "prose";
     let atLineStart = true;
     let lineBuf = "";
@@ -45,7 +45,7 @@ export function createStreamHighlighter(c, highlightLine = defaultLineHighlighte
                         lang = m[2] ? m[2].toLowerCase() : null;
                         carry = FRESH_CARRY;
                         mode = "code";
-                        out += c.dim(lineBuf) + "\n";
+                        out += theme.muted(lineBuf) + "\n";
                     }
                     else {
                         mode = "prose";
@@ -70,7 +70,7 @@ export function createStreamHighlighter(c, highlightLine = defaultLineHighlighte
                 if (ch === "\n") {
                     if (/^`{3,}\s*$/.test(lineBuf)) {
                         mode = "prose";
-                        out += c.dim(lineBuf) + "\n";
+                        out += theme.muted(lineBuf) + "\n";
                     }
                     else {
                         out += styleCodeLine(lineBuf) + "\n";
@@ -165,7 +165,7 @@ const WORD = /[A-Za-z0-9_$]/;
  * comments dim, strings green, keywords magenta, numbers yellow, everything
  * else untouched. Unknown language → identity.
  */
-export function defaultLineHighlighter(c) {
+export function defaultLineHighlighter(theme) {
     return (line, lang, carry) => {
         const def = lang ? LANGS[lang] : undefined;
         if (!def)
@@ -179,37 +179,37 @@ export function defaultLineHighlighter(c) {
         if (next.blockComment && def.blockComment) {
             const close = line.indexOf(def.blockComment[1]);
             if (close === -1)
-                return { text: c.dim(line), carry: next };
+                return { text: theme.syntax.comment(line), carry: next };
             const end = close + def.blockComment[1].length;
-            out += c.dim(line.slice(0, end));
+            out += theme.syntax.comment(line.slice(0, end));
             i = end;
             next.blockComment = false;
         }
         else if (next.stringDelim) {
             const close = findStringEnd(line, 0, next.stringDelim);
             if (close === -1)
-                return { text: c.green(line), carry: next };
-            out += c.green(line.slice(0, close));
+                return { text: theme.syntax.string(line), carry: next };
+            out += theme.syntax.string(line.slice(0, close));
             i = close;
             next.stringDelim = null;
         }
         while (i < line.length) {
             const rest = line.slice(i);
             if (def.lineComment && rest.startsWith(def.lineComment)) {
-                out += c.dim(rest);
+                out += theme.syntax.comment(rest);
                 i = line.length;
                 break;
             }
             if (def.blockComment && rest.startsWith(def.blockComment[0])) {
                 const close = line.indexOf(def.blockComment[1], i + def.blockComment[0].length);
                 if (close === -1) {
-                    out += c.dim(rest);
+                    out += theme.syntax.comment(rest);
                     next = { ...next, blockComment: true };
                     i = line.length;
                     break;
                 }
                 const end = close + def.blockComment[1].length;
-                out += c.dim(line.slice(i, end));
+                out += theme.syntax.comment(line.slice(i, end));
                 i = end;
                 continue;
             }
@@ -217,13 +217,13 @@ export function defaultLineHighlighter(c) {
             if (quote) {
                 const close = findStringEnd(line, i + quote.length, quote);
                 if (close === -1) {
-                    out += c.green(rest);
+                    out += theme.syntax.string(rest);
                     if (def.multiline.includes(quote))
                         next = { ...next, stringDelim: quote };
                     i = line.length;
                     break;
                 }
-                out += c.green(line.slice(i, close));
+                out += theme.syntax.string(line.slice(i, close));
                 i = close;
                 continue;
             }
@@ -234,9 +234,9 @@ export function defaultLineHighlighter(c) {
                     j++;
                 const word = line.slice(i, j);
                 if (def.keywords.has(word))
-                    out += c.magenta(word);
+                    out += theme.syntax.keyword(word);
                 else if (/^\d/.test(word))
-                    out += c.yellow(word);
+                    out += theme.syntax.number(word);
                 else
                     out += word;
                 i = j;

package/dist/render/index.d.ts

@@ -2,7 +2,7 @@ import type { RenderStream, StreamRenderer } from "./types.js";
 export type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, TokenUsage, ToolLifecycleEvent, } from "./types.js";
 export { detectCapabilities } from "./capabilities.js";
 export { composeStatusLine, describePhase, ELAPSED_AFTER_MS, formatElapsed, formatTokens, phaseIdentity, } from "./state.js";
-export { renderActionPreview, PREVIEW_MAX_LINES, type Colors } from "./diff.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";
 export { TtyRenderer } from "./tty-renderer.js";

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

@@ -1,4 +1,5 @@
 import type { ActionPreview } from "../tools/types.js";
+import { type Theme } from "../theme/index.js";
 import type { RenderCapabilities, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
 /**
  * The append-only renderer for pipes, CI, and cursor-less terminals. Emits no
@@ -15,7 +16,7 @@ export declare class PlainRenderer implements StreamRenderer {
     readonly caps: RenderCapabilities;
     private readonly out;
     private readonly err;
-    private readonly colors;
+    readonly theme: Theme;
     /** Per-turn leading-newline trim; also tells endSegment whether to newline. */
     private print;
     private wroteInSegment;

package/dist/render/plain-renderer.js

@@ -1,4 +1,4 @@
-import pc from "picocolors";
+import { resolveTheme } from "../theme/index.js";
 import { createStreamPrinter } from "../cli/stream-print.js";
 import { renderActionPreview } from "./diff.js";
 import { ELAPSED_AFTER_MS, formatElapsed } from "./state.js";
@@ -17,7 +17,7 @@ export class PlainRenderer {
     caps;
     out;
     err;
-    colors;
+    theme;
     /** Per-turn leading-newline trim; also tells endSegment whether to newline. */
     print;
     wroteInSegment = false;
@@ -27,7 +27,7 @@ export class PlainRenderer {
         this.caps = caps;
         this.out = out;
         this.err = err;
-        this.colors = pc.createColors(caps.color);
+        this.theme = resolveTheme(caps);
         this.print = this.newPrinter();
     }
     newPrinter() {
@@ -49,10 +49,10 @@ export class PlainRenderer {
         this.wroteInSegment = false;
     }
     note(text) {
-        this.err.write(this.colors.dim(text) + "\n");
+        this.err.write(this.theme.muted(text) + "\n");
     }
     preview(preview) {
-        const block = renderActionPreview(preview, this.colors);
+        const block = renderActionPreview(preview, this.theme);
         if (block)
             this.out.write(block + "\n");
     }
@@ -77,7 +77,8 @@ export class PlainRenderer {
         this.toolStart = null;
         const elapsed = started === null ? 0 : Date.now() - started.at;
         const suffix = elapsed >= ELAPSED_AFTER_MS ? ` (${formatElapsed(elapsed)})` : "";
-        this.note(`${event.ok ? "✓" : "✗"} ${event.label}${suffix}`);
+        const mark = event.ok ? this.theme.glyph.success : this.theme.glyph.failure;
+        this.note(`${mark} ${event.label}${suffix}`);
     }
     promptResolved() {
         // No live region to restore.

package/dist/render/state.d.ts

@@ -1,9 +1,14 @@
+import { type ThemeGlyphs } from "../theme/index.js";
 import type { ProgressState, RenderPhase } from "./types.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
  * terminal in sight. Color is deliberately absent — the live line is drawn
  * dim as a whole by the TTY renderer; state text is content, not chrome.
+ *
+ * Glyphs (ellipsis, token arrows, the ` · ` joiner) come from the theme (U.1);
+ * they default to the unicode table so colorless/test callers are unchanged,
+ * and the TTY renderer passes its capability-resolved set for ASCII fallback.
  */
 /**
  * Threshold before elapsed time appears on a live state or a committed tool
@@ -16,7 +21,7 @@ export declare function formatTokens(n: number): string;
 /** `37s`, `2m08s` — durations at status-line width. */
 export declare function formatElapsed(ms: number): string;
 /** The live-line text for a phase. `awaiting-approval` never renders (the line hides). */
-export declare function describePhase(phase: RenderPhase): string;
+export declare function describePhase(phase: RenderPhase, glyph?: ThemeGlyphs): string;
 /**
  * Identity key for the elapsed clock: the clock resets when the phase becomes
  * a *different activity*, not on every payload update — a thinking phase that
@@ -28,4 +33,4 @@ export declare function phaseIdentity(phase: RenderPhase | null): string;
  * Elapsed appears only past {@link ELAPSED_AFTER_MS} — callers pass it only
  * when they can keep it ticking honestly (no timer → no frozen number).
  */
-export declare function composeStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs?: number): string;
+export declare function composeStatusLine(progress: ProgressState | null, phase: RenderPhase | null, elapsedMs?: number, glyph?: ThemeGlyphs): string;

package/dist/render/state.js

@@ -1,8 +1,13 @@
+import { UNICODE_GLYPHS } from "../theme/index.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
  * terminal in sight. Color is deliberately absent — the live line is drawn
  * dim as a whole by the TTY renderer; state text is content, not chrome.
+ *
+ * Glyphs (ellipsis, token arrows, the ` · ` joiner) come from the theme (U.1);
+ * they default to the unicode table so colorless/test callers are unchanged,
+ * and the TTY renderer passes its capability-resolved set for ASCII fallback.
  */
 /**
  * Threshold before elapsed time appears on a live state or a committed tool
@@ -28,23 +33,24 @@ export function formatElapsed(ms) {
     return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
 }
 /** The live-line text for a phase. `awaiting-approval` never renders (the line hides). */
-export function describePhase(phase) {
+export function describePhase(phase, glyph = UNICODE_GLYPHS) {
+    const e = glyph.ellipsis;
     switch (phase.kind) {
         case "thinking": {
             const t = phase.tokens;
             // Honest numbers only: no usage yet → no figure at all.
             return t && t.input + t.output > 0
-                ? `thinking… · tokens ↑${formatTokens(t.input)} ↓${formatTokens(t.output)}`
-                : "thinking…";
+                ? `thinking${e} ${glyph.sep} tokens ${glyph.caretUp}${formatTokens(t.input)} ${glyph.caretDown}${formatTokens(t.output)}`
+                : `thinking${e}`;
         }
         case "calling-tool":
-            return `${phase.label}…`;
+            return `${phase.label}${e}`;
         case "awaiting-approval":
-            return "awaiting approval…";
+            return `awaiting approval${e}`;
         case "executing-step":
-            return "working…";
+            return `working${e}`;
         case "subagent":
-            return `subagent: ${phase.label}…`;
+            return `subagent: ${phase.label}${e}`;
     }
 }
 /**
@@ -69,13 +75,13 @@ export function phaseIdentity(phase) {
  * Elapsed appears only past {@link ELAPSED_AFTER_MS} — callers pass it only
  * when they can keep it ticking honestly (no timer → no frozen number).
  */
-export function composeStatusLine(progress, phase, elapsedMs) {
+export function composeStatusLine(progress, phase, elapsedMs, glyph = UNICODE_GLYPHS) {
     const parts = [];
     if (progress)
         parts.push(`[${progress.step}/${progress.of}] ${progress.title}`);
     if (phase)
-        parts.push(describePhase(phase));
-    const line = parts.join(" · ");
+        parts.push(describePhase(phase, glyph));
+    const line = parts.join(` ${glyph.sep} `);
     if (elapsedMs !== undefined && elapsedMs >= ELAPSED_AFTER_MS) {
         return `${line} (${formatElapsed(elapsedMs)})`;
     }

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

@@ -1,4 +1,5 @@
 import type { ActionPreview } from "../tools/types.js";
+import { type Theme } from "../theme/index.js";
 import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, StreamRenderer, ToolLifecycleEvent } from "./types.js";
 /**
  * The interactive renderer: committed content is append-only; the one transient
@@ -28,7 +29,7 @@ import type { ProgressState, RenderCapabilities, RenderPhase, RenderStream, Stre
 export declare class TtyRenderer implements StreamRenderer {
     readonly caps: RenderCapabilities;
     private readonly out;
-    private readonly colors;
+    readonly theme: Theme;
     private print;
     private highlighter;
     private wroteInSegment;

package/dist/render/tty-renderer.js

@@ -1,13 +1,10 @@
-import pc from "picocolors";
+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";
 /** Erase the current line and return the cursor to column 0. */
 const CLEAR_LINE = "\r\x1b[2K";
-/** Spinner frames (braille); a static glyph when animation is disabled. */
-const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const STATIC_FRAME = "◐";
 const SPINNER_INTERVAL_MS = 100;
 /**
  * The interactive renderer: committed content is append-only; the one transient
@@ -37,7 +34,7 @@ const SPINNER_INTERVAL_MS = 100;
 export class TtyRenderer {
     caps;
     out;
-    colors;
+    theme;
     print;
     highlighter;
     wroteInSegment = false;
@@ -59,8 +56,8 @@ export class TtyRenderer {
     constructor(caps, out) {
         this.caps = caps;
         this.out = out;
-        this.colors = pc.createColors(caps.color);
-        this.highlighter = createStreamHighlighter(this.colors);
+        this.theme = resolveTheme(caps);
+        this.highlighter = createStreamHighlighter(this.theme);
         this.print = this.newPrinter();
     }
     newPrinter() {
@@ -115,7 +112,7 @@ export class TtyRenderer {
         const elapsed = this.phase !== null && this.caps.spinner
             ? Date.now() - this.phaseStartedAt
             : undefined;
-        return composeStatusLine(this.progressState, this.phase, elapsed);
+        return composeStatusLine(this.progressState, this.phase, elapsed, this.theme.glyph);
     }
     /** Redraw the live line from current state, or hide it when there is none. */
     refresh() {
@@ -138,16 +135,19 @@ export class TtyRenderer {
     }
     drawLine(text) {
         this.lineVisible = true;
+        const frames = this.theme.glyph.spinnerFrames;
         const glyph = this.caps.spinner
-            ? FRAMES[this.frame % FRAMES.length]
-            : STATIC_FRAME;
+            ? frames[this.frame % frames.length]
+            : this.theme.glyph.spinnerStatic;
         // Reserve glyph + space; truncate so the live line can never soft-wrap.
         const room = Math.max(1, this.caps.width - 2);
-        const line = text.length > room ? text.slice(0, Math.max(0, room - 1)) + "…" : text;
-        this.out.write(`${CLEAR_LINE}${this.colors.cyan(glyph)} ${this.colors.dim(line)}`);
+        const line = text.length > room
+            ? text.slice(0, Math.max(0, room - 1)) + this.theme.glyph.ellipsis
+            : text;
+        this.out.write(`${CLEAR_LINE}${this.theme.accent(glyph)} ${this.theme.muted(line)}`);
     }
     beginTurn() {
-        this.highlighter = createStreamHighlighter(this.colors);
+        this.highlighter = createStreamHighlighter(this.theme);
         this.print = this.newPrinter();
         this.wroteInSegment = false;
     }
@@ -169,13 +169,15 @@ export class TtyRenderer {
         if (this.closed)
             return;
         const room = Math.max(1, this.caps.width);
-        const line = text.length > room ? text.slice(0, room - 1) + "…" : text;
-        this.commit(this.colors.dim(line) + "\n");
+        const line = text.length > room
+            ? text.slice(0, room - 1) + this.theme.glyph.ellipsis
+            : text;
+        this.commit(this.theme.muted(line) + "\n");
     }
     preview(preview) {
         if (this.closed)
             return;
-        const block = renderActionPreview(preview, this.colors);
+        const block = renderActionPreview(preview, this.theme);
         if (block)
             this.commit(block + "\n");
     }
@@ -237,7 +239,8 @@ export class TtyRenderer {
         // honest even with CRUXY_NO_SPINNER; shown only once it means something.
         const elapsed = started === null ? 0 : Date.now() - started.at;
         const suffix = elapsed >= ELAPSED_AFTER_MS ? ` (${formatElapsed(elapsed)})` : "";
-        this.note(`${event.ok ? "✓" : "✗"} ${event.label}${suffix}`);
+        const mark = event.ok ? this.theme.glyph.success : this.theme.glyph.failure;
+        this.note(`${mark} ${event.label}${suffix}`);
     }
     promptResolved() {
         if (this.closed)

package/dist/render/types.d.ts

@@ -1,4 +1,5 @@
 import type { ActionPreview } from "../tools/types.js";
+import type { Theme } from "../theme/index.js";
 /**
  * The streaming render seam (U.2): the agent loop talks to a
  * {@link StreamRenderer}, never to raw stdout. Two implementations exist —
@@ -21,6 +22,9 @@ export interface RenderCapabilities {
     cursor: boolean;
     /** Animation is welcome (`cursor` and CRUXY_NO_SPINNER unset). */
     spinner: boolean;
+    /** 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). */
     width: number;
 }
@@ -97,6 +101,9 @@ export type ToolLifecycleEvent = {
  */
 export interface StreamRenderer {
     readonly caps: RenderCapabilities;
+    /** The one resolved design system (U.1) — glyphs/roles for chrome a
+     * surface emits through this renderer (e.g. the subagent trail notes). */
+    readonly theme: Theme;
     /** Start a user turn: reset leading-newline trim and code-fence state. */
     beginTurn(): void;
     /**

package/dist/subagent/orchestrator.js

@@ -67,7 +67,9 @@ export class SubagentOrchestrator {
             },
         };
         const label = taskLabel(spec.task);
-        deps.renderer?.note(`⏵ subagent: ${label}`);
+        if (deps.renderer) {
+            deps.renderer.note(`${deps.renderer.theme.glyph.play} subagent: ${label}`);
+        }
         deps.renderer?.setPhase({ kind: "subagent", label });
         // The isolation seam: a brand-new history seeded with ONLY the task. The
         // parent's messages are never in scope here, and this array dies with the
@@ -96,7 +98,9 @@ export class SubagentOrchestrator {
                 deps.renderer?.setPhase(null);
                 throw err;
             }
-            deps.renderer?.note(`✗ subagent failed: ${label}`);
+            if (deps.renderer) {
+                deps.renderer.note(`${deps.renderer.theme.glyph.failure} subagent failed: ${label}`);
+            }
             deps.renderer?.setPhase(null);
             return {
                 status: "failed",
@@ -123,7 +127,9 @@ export class SubagentOrchestrator {
             usage: run.usage,
         };
         if (run.stop === "completed") {
-            this.deps.renderer?.note(`✓ subagent done: ${label}`);
+            const r = this.deps.renderer;
+            if (r)
+                r.note(`${r.theme.glyph.success} subagent done: ${label}`);
             return { status: "done", ...base };
         }
         // Both cap paths are the same outcome for the parent: a truncated, partial
@@ -132,7 +138,9 @@ export class SubagentOrchestrator {
         const reason = run.stop === "budget"
             ? (run.stopReason ?? "budget cap reached")
             : `agent.maxIterations ceiling reached (${this.deps.config.agent.maxIterations})`;
-        this.deps.renderer?.note(`✗ subagent stopped (budget): ${label}`);
+        const r = this.deps.renderer;
+        if (r)
+            r.note(`${r.theme.glyph.failure} subagent stopped (budget): ${label}`);
         return {
             status: "budget-exceeded",
             ...base,
@@ -195,12 +203,16 @@ function lastAssistantText(messages) {
  */
 class SubagentRenderer {
     caps;
+    theme;
     inner;
     label;
+    prefix;
     constructor(inner, label) {
         this.inner = inner;
         this.label = label;
         this.caps = inner.caps;
+        this.theme = inner.theme;
+        this.prefix = `subagent ${inner.theme.glyph.sep} `;
     }
     /** Turn framing belongs to the parent's turn — the child's is dropped. */
     beginTurn() { }
@@ -209,7 +221,7 @@ class SubagentRenderer {
     write() { }
     endSegment() { }
     note(text) {
-        this.inner.note(`subagent · ${text}`);
+        this.inner.note(`${this.prefix}${text}`);
     }
     preview(preview) {
         this.inner.preview(preview);
@@ -231,7 +243,10 @@ class SubagentRenderer {
     /** The plan executor owns the progress register (C.31) — never the child. */
     progress() { }
     toolLifecycle(event) {
-        this.inner.toolLifecycle({ ...event, label: `subagent · ${event.label}` });
+        this.inner.toolLifecycle({
+            ...event,
+            label: `${this.prefix}${event.label}`,
+        });
     }
     promptResolved() {
         this.inner.promptResolved();

package/dist/theme/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./tokens.js";
+export * from "./resolve.js";

package/dist/theme/index.js

@@ -0,0 +1,2 @@
+export * from "./tokens.js";
+export * from "./resolve.js";

package/dist/theme/resolve.d.ts

@@ -0,0 +1,32 @@
+import { type Theme, type ThemeCapabilities } from "./tokens.js";
+/**
+ * Theme resolution (U.1) — the ONE place picocolors is used. The two axes are
+ * fully independent by construction:
+ *
+ * - `color` drives the stylers only. `pc.createColors(false)` is the identity,
+ *   so NO_COLOR yields zero ANSI bytes (dim/bold vanish too) — asserted in the
+ *   tests.
+ * - `unicode` drives the glyph table only. It never touches color: a NO_COLOR
+ *   unicode terminal still prints ✓/✗ (glyphs aren't ANSI), and a colored
+ *   CRUXY_ASCII terminal prints a colored `[ok]`.
+ */
+export declare function resolveTheme(caps: ThemeCapabilities): Theme;
+/**
+ * Whether the terminal can render unicode glyphs. `TERM=dumb` and an explicit
+ * `CRUXY_ASCII` opt-in fall back to the ASCII table; everything else (real
+ * terminals AND pipes) keeps unicode — piping ✓/✗ to a file is fine, and this
+ * preserves pre-U.1 behavior for non-TTY output.
+ *
+ * The single source of the rule: `render/capabilities.ts` calls this to fill
+ * `RenderCapabilities.unicode`, and the boolean-seam surfaces (errors,
+ * approval, plan, onboarding, CLI commands) call it to build a theme without a
+ * signature change.
+ */
+export declare function detectUnicode(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Build a theme for a surface that only knows a `color` boolean (the U.3
+ * PromptIO, error formatting, plan/onboarding/CLI copy). Unicode is detected
+ * from the environment so these surfaces still degrade on dumb terminals,
+ * with no change to their public boolean signatures.
+ */
+export declare function themeForColor(color: boolean, env?: NodeJS.ProcessEnv): Theme;

package/dist/theme/resolve.js

@@ -0,0 +1,73 @@
+import pc from "picocolors";
+import { ASCII_GLYPHS, UNICODE_GLYPHS, } from "./tokens.js";
+/**
+ * Theme resolution (U.1) — the ONE place picocolors is used. The two axes are
+ * fully independent by construction:
+ *
+ * - `color` drives the stylers only. `pc.createColors(false)` is the identity,
+ *   so NO_COLOR yields zero ANSI bytes (dim/bold vanish too) — asserted in the
+ *   tests.
+ * - `unicode` drives the glyph table only. It never touches color: a NO_COLOR
+ *   unicode terminal still prints ✓/✗ (glyphs aren't ANSI), and a colored
+ *   CRUXY_ASCII terminal prints a colored `[ok]`.
+ */
+export function resolveTheme(caps) {
+    const c = pc.createColors(caps.color);
+    const glyph = caps.unicode ? UNICODE_GLYPHS : ASCII_GLYPHS;
+    const strong = c.bold;
+    const indent = (text, level = 1) => {
+        const pad = "  ".repeat(Math.max(0, level));
+        return text
+            .split("\n")
+            .map((line) => (line === "" ? line : pad + line))
+            .join("\n");
+    };
+    return {
+        danger: c.red,
+        warning: c.yellow,
+        success: c.green,
+        accent: c.cyan,
+        muted: c.dim,
+        strong,
+        syntax: {
+            keyword: c.magenta,
+            string: c.green,
+            number: c.yellow,
+            comment: c.dim,
+        },
+        glyph,
+        heading: strong,
+        indent,
+        kv: (key, value, keyWidth) => `${strong(keyWidth ? key.padEnd(keyWidth) : key)}  ${value}`,
+        sep: ` ${glyph.sep} `,
+        color: caps.color,
+        unicode: caps.unicode,
+    };
+}
+/**
+ * Whether the terminal can render unicode glyphs. `TERM=dumb` and an explicit
+ * `CRUXY_ASCII` opt-in fall back to the ASCII table; everything else (real
+ * terminals AND pipes) keeps unicode — piping ✓/✗ to a file is fine, and this
+ * preserves pre-U.1 behavior for non-TTY output.
+ *
+ * The single source of the rule: `render/capabilities.ts` calls this to fill
+ * `RenderCapabilities.unicode`, and the boolean-seam surfaces (errors,
+ * approval, plan, onboarding, CLI commands) call it to build a theme without a
+ * signature change.
+ */
+export function detectUnicode(env = process.env) {
+    if (env.CRUXY_ASCII !== undefined && env.CRUXY_ASCII !== "")
+        return false;
+    if (env.TERM === "dumb")
+        return false;
+    return true;
+}
+/**
+ * Build a theme for a surface that only knows a `color` boolean (the U.3
+ * PromptIO, error formatting, plan/onboarding/CLI copy). Unicode is detected
+ * from the environment so these surfaces still degrade on dumb terminals,
+ * with no change to their public boolean signatures.
+ */
+export function themeForColor(color, env = process.env) {
+    return resolveTheme({ color, unicode: detectUnicode(env) });
+}