s-app-scoder-agent 0.5.0 → 0.7.0

package/dist/tui/state.js

@@ -0,0 +1,342 @@
+export function initialState() {
+    return {
+        items: [],
+        status: "idle",
+        step: 0,
+        maxSteps: 0,
+        model: "",
+        provider: "",
+        workdir: "",
+        buildCmd: "",
+        buildLamp: "none",
+        permission: "",
+        startedAt: null,
+        endedAt: null,
+        usage: { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 },
+        summary: null,
+        guardrailCount: 0,
+        lastGuardrail: null,
+        thinkingVisible: false,
+        phases: [],
+        mcpServers: {},
+        streamingOutputChars: 0,
+    };
+}
+const MAX_ITEMS = 400;
+const MAX_OUTPUT_CHARS = 20_000;
+const MAX_TEXT_CHARS = 40_000;
+/**
+ * T4: ước lượng chiều cao (rows) của một ChatItem khi render — dùng cho
+ * virtualization (chỉ render window quanh viewport thay vì cap cứng).
+ * Over-estimate nhẹ an toàn hơn under-estimate (viewport luôn đủ phủ).
+ * ponytail: heuristic theo chars, không đo Ink thật — nâng cấp thành đo
+ * height thật (useBoxMetrics per item) khi heuristic lệch đáng kể.
+ */
+export function estimateItemRows(item) {
+    switch (item.kind) {
+        case "user":
+            return 2 + Math.ceil(item.text.length / 80);
+        case "assistant":
+        case "thinking":
+            return 1 + Math.ceil((item.text?.length ?? 0) / 80) + (item.text ? item.text.split("\n").length : 0);
+        case "tool":
+            return 1 + 2; // title + preview 2 lines
+        case "diff":
+            return 3 + Math.min(24, (item.text?.split("\n").length ?? 0)); // header + ≤24 lines + border
+        case "todo":
+            return 2 + item.items.length;
+        case "build":
+            return 1;
+        case "notice":
+            return 1 + Math.ceil(item.text.length / 2000);
+    }
+}
+/**
+ * T4: chọn window item để render: lấy từ cuối lên tới khi tổng rows ước
+ * lượng ≥ viewportRows + margin (render dư phía trên để scroll mượt), nhưng
+ * giữ toàn bộ khi tổng nhỏ. Trả về slice của items (không mutate).
+ */
+export function visibleWindow(items, viewportRows, margin = 50) {
+    const budget = viewportRows + margin;
+    let acc = 0;
+    let start = items.length;
+    while (start > 0 && acc < budget) {
+        start--;
+        acc += estimateItemRows(items[start]);
+    }
+    return start === 0 ? items : items.slice(start);
+}
+/**
+ * Plan mới nhất cho sidebar — todo items được append mỗi lần update nhưng
+ * sidebar chỉ cần snapshot hiện tại (last-wins), null khi chưa có plan.
+ */
+export function latestPlan(items) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        const it = items[i];
+        if (it.kind === "todo")
+            return it;
+    }
+    return null;
+}
+function appendItem(state, item) {
+    state.items.push(item);
+    if (state.items.length > MAX_ITEMS)
+        state.items.splice(0, state.items.length - MAX_ITEMS);
+}
+function lastItem(state) {
+    return state.items[state.items.length - 1];
+}
+/** Cap long strings, keeping the tail (errors usually live at the end). */
+function capTail(text, max = MAX_OUTPUT_CHARS) {
+    if (text.length <= max)
+        return text;
+    return `…[truncated ${text.length - max} chars]\n${text.slice(text.length - max)}`;
+}
+/**
+ * Map tên tool → phase của breadcrumb (plan→explore→edit→build→verify).
+ * Trả về null với tool không thuộc phase nào (mcp__*...).
+ */
+export function toolPhase(name) {
+    if (name === "write_todos")
+        return "plan";
+    if (name === "list_files" || name === "read_file" || name === "web_fetch" || name === "load_skill")
+        return "explore";
+    if (name === "write_file" || name === "edit_file")
+        return "edit";
+    if (name === "run_command")
+        return "build";
+    return null;
+}
+/** Guardrail event: đếm + giữ decision gần nhất (ngắn, tự giải thích cho header). */
+function applyGuardrail(state, ev) {
+    // history-trim là routine context management — đếm làm gì, hiện làm gì:
+    // header chỉ hiển thị những can thiệp THẬT sự đáng chú ý (inject/finish/verify).
+    if (ev.action === "trim")
+        return;
+    state.guardrailCount += 1;
+    // Thông điệp thân thiện theo rule — không dump raw "rule · reason" lên UI.
+    const HUMAN = {
+        "wrap-up": "sắp hết bước — yêu cầu agent chốt việc và chạy build",
+        "chat-done": "lượt chat thuần — kết thúc không cần build",
+        "completion-claim": "agent báo hoàn thành — buộc chạy build xác minh",
+        "text-only-streak": "agent chỉ nói không làm — dừng run",
+        "continue-nudge": "agent trả lời text mà không dùng tool — nhắc tiếp tục làm việc",
+        "doom-loop": "lặp lẫn lộn cùng tool call — yêu cầu đổi hướng",
+        "build-stop": "build pass — kết thúc run",
+    };
+    state.lastGuardrail = HUMAN[ev.rule] ?? `${ev.rule}: ${ev.reason}`;
+    if (state.lastGuardrail.length > 72)
+        state.lastGuardrail = state.lastGuardrail.slice(0, 69) + "…";
+}
+/**
+ * Fold one AgentEvent into the state (mutates `state`, returns it for
+ * reducer-style chaining). Unknown events are ignored.
+ */
+export function applyEvent(state, ev) {
+    switch (ev.type) {
+        case "permission_request": {
+            // T-03: surfaced via a dedicated React state hook in TuiApp (not the
+            // chat items — the modal is modal, not transcript).
+            break;
+        }
+        case "run_start": {
+            state.model = ev.model;
+            state.provider = ev.provider;
+            state.workdir = ev.workdir;
+            state.buildCmd = ev.buildCmd;
+            state.buildLamp = "none";
+            state.permission = ev.permission;
+            state.startedAt = Date.now();
+            state.endedAt = null;
+            state.status = "running";
+            state.step = 0;
+            state.summary = null;
+            state.usage = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
+            // Reset tracking của run mới.
+            state.guardrailCount = 0;
+            state.lastGuardrail = null;
+            state.phases = [];
+            state.streamingOutputChars = 0;
+            // The TUI pushes the user's message itself when submitting; avoid a
+            // duplicate when run_start carries the same task.
+            const last = lastItem(state);
+            if (!(last && last.kind === "user" && last.text === ev.task)) {
+                appendItem(state, { kind: "user", text: ev.task });
+            }
+            break;
+        }
+        case "llm_reasoning": {
+            // T-10: thinking stream — chỉ append khi thinkingVisible; vẫn giữ trong
+            // reasoning buffer riêng để toggle bật lại thấy (đơn giản: drop khi off).
+            if (!state.thinkingVisible)
+                break;
+            const last = lastItem(state);
+            if (last && last.kind === "thinking" && last.streaming) {
+                last.text += ev.delta;
+                if (last.text.length > MAX_TEXT_CHARS)
+                    last.text = last.text.slice(-MAX_TEXT_CHARS);
+            }
+            else {
+                appendItem(state, { kind: "thinking", text: ev.delta, streaming: true });
+            }
+            break;
+        }
+        case "step": {
+            state.step = ev.step;
+            state.maxSteps = ev.maxSteps;
+            // A new step starts: close any still-"streaming" assistant message.
+            const last = lastItem(state);
+            if (last && last.kind === "assistant" && last.streaming)
+                last.streaming = false;
+            if (last && last.kind === "thinking" && last.streaming)
+                last.streaming = false;
+            break;
+        }
+        case "llm_delta": {
+            state.streamingOutputChars += ev.delta.length;
+            const last = lastItem(state);
+            if (last && last.kind === "assistant" && last.streaming) {
+                last.text += ev.delta;
+                if (last.text.length > MAX_TEXT_CHARS)
+                    last.text = last.text.slice(-MAX_TEXT_CHARS);
+            }
+            else {
+                if (last && last.kind === "assistant" && last.streaming === false && last.text === "") {
+                    // reuse an empty assistant placeholder from a previous step
+                    last.streaming = true;
+                }
+                else {
+                    appendItem(state, { kind: "assistant", text: ev.delta, streaming: true });
+                }
+            }
+            break;
+        }
+        case "llm_usage": {
+            state.usage.calls += 1;
+            state.usage.inputTokens += ev.usage.input_tokens ?? 0;
+            state.usage.outputTokens += ev.usage.output_tokens ?? 0;
+            state.usage.cachedTokens += ev.usage.cached_tokens ?? 0;
+            break;
+        }
+        case "tool_call": {
+            appendItem(state, {
+                kind: "tool",
+                name: ev.name,
+                args: ev.args,
+                callId: ev.id,
+                ok: null,
+                output: "",
+                step: ev.step,
+                startedAt: Date.now(),
+            });
+            // Phase tracking cho breadcrumb (không trùng phase liền trước).
+            const phase = toolPhase(ev.name);
+            if (phase && state.phases[state.phases.length - 1] !== phase)
+                state.phases.push(phase);
+            break;
+        }
+        case "tool_output": {
+            // Live stdout/stderr chunks attach to the most recent running tool item.
+            for (let i = state.items.length - 1; i >= 0; i--) {
+                const it = state.items[i];
+                if (it.kind === "tool" && it.ok === null && it.name === ev.name) {
+                    it.output += ev.delta;
+                    if (it.output.length > MAX_OUTPUT_CHARS)
+                        it.output = capTail(it.output);
+                    break;
+                }
+                // Stop searching at the previous tool boundary to avoid cross-attachment.
+                if (it.kind === "tool")
+                    break;
+            }
+            break;
+        }
+        case "tool_result": {
+            // T6: correlate theo callId (parallel calls cùng tên vẫn đúng card);
+            // fallback theo name cho event cũ không id.
+            for (let i = state.items.length - 1; i >= 0; i--) {
+                const it = state.items[i];
+                const match = it.kind === "tool" && it.ok === null && (ev.id ? it.callId === ev.id : it.name === ev.name);
+                if (match) {
+                    it.ok = ev.ok;
+                    if (it.startedAt != null)
+                        it.durationMs = Date.now() - it.startedAt;
+                    // Prefer the final (complete) result over accumulated live chunks.
+                    if (ev.output.length >= it.output.length)
+                        it.output = ev.output;
+                    if (ev.image)
+                        it.image = ev.image;
+                    break;
+                }
+            }
+            // File-writing tools attach a unified diff — render it as its own item
+            // so edits are reviewable at a glance (the scoder "✎" signature).
+            if (ev.diff) {
+                appendItem(state, {
+                    kind: "diff",
+                    path: ev.diff.path,
+                    text: ev.diff.text,
+                    added: ev.diff.added,
+                    removed: ev.diff.removed,
+                    truncated: ev.diff.truncated,
+                    step: ev.step,
+                });
+            }
+            break;
+        }
+        case "build": {
+            state.buildLamp = ev.success ? "ok" : "fail";
+            if (state.phases[state.phases.length - 1] !== "verify")
+                state.phases.push("verify");
+            appendItem(state, { kind: "build", success: ev.success, command: ev.command });
+            break;
+        }
+        case "todo": {
+            // Plan updates render as a live checkbox list in the chat pane.
+            appendItem(state, { kind: "todo", items: ev.items.map((t) => ({ ...t })) });
+            break;
+        }
+        case "guardrail": {
+            applyGuardrail(state, ev);
+            break;
+        }
+        case "mcp_status": {
+            // Sidebar: structured event (server+state) → cập nhật map, không spam chat.
+            // onStatus riêng vẫn đẩy notice text đầy đủ cho transcript.
+            if (ev.server && ev.state) {
+                state.mcpServers = { ...state.mcpServers, [ev.server]: ev.state };
+                break;
+            }
+            appendItem(state, { kind: "notice", text: ev.line, level: ev.line.includes("unavailable") ? "warn" : "info" });
+            break;
+        }
+        case "finish": {
+            state.status = ev.success ? "success" : /interrupted|aborted/i.test(ev.summary) ? "aborted" : "failed";
+            state.summary = ev.summary;
+            state.endedAt = Date.now();
+            // Close ALL dangling streaming assistant messages — not just the last
+            // item: a notice/tool item appended after the assistant text would
+            // otherwise leave it stuck in raw streaming mode (invisible text).
+            for (const it of state.items) {
+                if (it.kind === "assistant" && it.streaming)
+                    it.streaming = false;
+            }
+            break;
+        }
+        case "error": {
+            appendItem(state, { kind: "notice", text: ev.message, level: "error" });
+            break;
+        }
+    }
+    return state;
+}
+/** Mark the current run aborted from the UI side (before the finish event). */
+export function markAborted(state) {
+    state.status = "aborted";
+    state.summary = "abort requested…";
+    state.endedAt = Date.now();
+    const last = lastItem(state);
+    if (last && last.kind === "assistant")
+        last.streaming = false;
+    return state;
+}

package/dist/tui/theme.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+const MISSION = {
+    brand: "magenta", accent: "cyan", success: "green", error: "red", warn: "yellow",
+    user: "blue", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "green", table: "cyan",
+};
+const PAPER = {
+    brand: "blue", accent: "blue", success: "green", error: "red", warn: "yellow",
+    user: "black", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "green", table: "cyan",
+};
+const MONO = {
+    brand: "white", accent: "white", success: "white", error: "white", warn: "white",
+    user: "white", dim: "gray", border: "gray",
+    mermaid: "whiteBright", thinking: "white", code: "whiteBright", table: "whiteBright",
+};
+const LIGHT = {
+    brand: "magentaBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "blueBright", dim: "blackBright", border: "blackBright",
+    mermaid: "magentaBright", thinking: "gray", code: "greenBright", table: "cyanBright",
+};
+const HIGH_CONTRAST = {
+    brand: "whiteBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "whiteBright", dim: "white", border: "whiteBright",
+    mermaid: "magentaBright", thinking: "whiteBright", code: "greenBright", table: "cyanBright",
+};
+const SOLARIZED = {
+    brand: "magentaBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "blueBright", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "greenBright", table: "cyanBright",
+};
+export const THEMES = {
+    mission: MISSION, paper: PAPER, mono: MONO,
+    light: LIGHT, "high-contrast": HIGH_CONTRAST, solarized: SOLARIZED,
+};
+export function defaultThemeName(env = process.env) {
+    if (env.TERM === "dumb" || !env.TERM)
+        return "mono";
+    if (env.COLOR_COUNT && Number(env.COLOR_COUNT) < 16)
+        return "mono";
+    return "mission";
+}
+export function getTheme(workdir) {
+    const p = join(workdir, ".scoder", "theme.json");
+    if (existsSync(p)) {
+        try {
+            const raw = JSON.parse(readFileSync(p, "utf8"));
+            const base = raw.name ? THEMES[raw.name] ?? THEMES[defaultThemeName()] : THEMES[defaultThemeName()];
+            return { ...base, ...Object.fromEntries(Object.entries(raw).filter(([k]) => k in base)) };
+        }
+        catch { /* malformed → default */ }
+    }
+    return THEMES[defaultThemeName()];
+}
+let active = MISSION;
+export function setActiveTheme(t) { active = t; }
+export function useNamedTheme(name) {
+    if (name === "list")
+        return `themes: ${Object.keys(THEMES).join(", ")} — /theme <name>`;
+    const t = THEMES[name];
+    if (!t)
+        return `ERROR: unknown theme "${name}" — available: ${Object.keys(THEMES).join(", ")}`;
+    active = t;
+    return `theme → ${name}`;
+}
+export const theme = new Proxy({}, {
+    get(_t, prop) { return active[prop]; },
+});
+/** Icon per tool name — compact visual vocabulary for the flight recorder. */
+const TOOL_ICONS = {
+    list_files: "🗂", read_file: "📖", write_file: "📝", edit_file: "✏️",
+    run_command: "⚡", web_fetch: "🌐", write_todos: "☑",
+};
+export function toolIcon(name) {
+    if (TOOL_ICONS[name])
+        return TOOL_ICONS[name];
+    if (name.startsWith("mcp__"))
+        return "🔌";
+    return "🔧";
+}
+export function fit(text, max) {
+    return text.length <= max ? text : text.slice(0, Math.max(0, max - 1)) + "…";
+}
+/** The agent's signature mark, used as an avatar on assistant output. */
+export function AgentMark() {
+    return _jsx(Text, { color: theme.brand, bold: true, children: "\u25C6 " });
+}

package/dist/tui/vim.js

@@ -0,0 +1,60 @@
+/**
+ * T5: vim-motion cho Input — mode normal/insert, word motions.
+ * Module thuần (test được); Input chỉ wire keymap.
+ */
+/** w — đầu từ kế tiếp (vim: skip word chars rồi skip whitespace). */
+export function wordForward(s, i) {
+    while (i < s.length && /\S/.test(s[i]))
+        i++;
+    while (i < s.length && /\s/.test(s[i]))
+        i++;
+    return Math.min(i, s.length);
+}
+/** b — đầu từ trước. */
+export function wordBack(s, i) {
+    i--;
+    while (i > 0 && /\s/.test(s[i]))
+        i--;
+    while (i > 0 && /\S/.test(s[i - 1]))
+        i--;
+    return Math.max(0, i);
+}
+/** e — cuối từ hiện tại/kế tiếp. */
+export function wordEnd(s, i) {
+    i++;
+    while (i < s.length - 1 && /\s/.test(s[i]))
+        i++;
+    while (i < s.length - 1 && /\S/.test(s[i + 1]))
+        i++;
+    return Math.min(i, Math.max(0, s.length - 1));
+}
+/** Áp dụng một phím normal-mode. Trả về unhandled=true khi không phải motion. */
+export function applyNormalKey(value, cursor, input) {
+    const ok = (v, c, mode = "normal") => ({ value: v, cursor: c, mode, unhandled: false });
+    switch (input) {
+        case "h":
+            return ok(value, Math.max(0, cursor - 1));
+        case "l":
+            return ok(value, Math.min(value.length, cursor + 1));
+        case "w":
+            return ok(value, wordForward(value, cursor));
+        case "b":
+            return ok(value, wordBack(value, cursor));
+        case "e":
+            return ok(value, wordEnd(value, cursor));
+        case "0":
+            return ok(value, 0);
+        case "$":
+            return ok(value, value.length);
+        case "x":
+            return cursor < value.length ? ok(value.slice(0, cursor) + value.slice(cursor + 1), cursor) : ok(value, cursor);
+        case "i":
+            return ok(value, cursor, "insert");
+        case "a":
+            return ok(value, Math.min(value.length, cursor + 1), "insert");
+        case "A":
+            return ok(value, value.length, "insert");
+        default:
+            return { value, cursor, mode: "normal", unhandled: true };
+    }
+}

package/dist/ui.js

@@ -1,6 +1,14 @@
 import process from "node:process";
 // Honor NO_COLOR and non-TTY output: drop ANSI codes so logs/CI stay clean.
 const COLOR = process.env.NO_COLOR === undefined && process.stdout.isTTY === true;
+// When a full-screen TUI is active (scoder tui), the Agent's console output
+// would corrupt Ink's alt-screen rendering. The TUI renders from AgentEvents
+// instead; setting QUIET suppresses every direct ui.* write.
+let QUIET = false;
+/** Suppress all direct console writes from ui.* (used by the Ink TUI frontend). */
+export function setQuiet(quiet) {
+    QUIET = quiet;
+}
 const RESET = COLOR ? "\x1b[0m" : "";
 const BOLD = COLOR ? "\x1b[1m" : "";
 const DIM = COLOR ? "\x1b[2m" : "";
@@ -13,43 +21,65 @@ function ts() {
     return new Date().toISOString().slice(11, 23);
 }
 export function info(msg) {
+    if (QUIET)
+        return;
     console.log(`${DIM}[${ts()}]${RESET} ${msg}`);
 }
 export function step(stepNum, total, msg) {
+    if (QUIET)
+        return;
     console.log(`${BLUE}[${String(stepNum).padStart(2)}/${total}]${RESET} ${BOLD}▸ ${msg}${RESET}`);
 }
 export function success(msg) {
+    if (QUIET)
+        return;
     console.log(`${GREEN}✓${RESET} ${GREEN}${msg}${RESET}`);
 }
 export function warn(msg) {
+    if (QUIET)
+        return;
     console.log(`${YELLOW}⚠${RESET} ${YELLOW}${msg}${RESET}`);
 }
 export function error(msg) {
+    if (QUIET)
+        return;
     console.error(`${RED}✗${RESET} ${RED}${msg}${RESET}`);
 }
 export function llm(prefix, content) {
+    if (QUIET)
+        return;
     console.log(`${CYAN}${prefix}:${RESET} ${content.slice(0, 300)}${content.length > 300 ? " ..." : ""}`);
 }
 export function toolCall(name, args) {
+    if (QUIET)
+        return;
     const a = Object.entries(args)
         .map(([k, v]) => `${k}=${JSON.stringify(v)?.slice(0, 80)}`)
         .join(" ");
     console.log(`${CYAN}→ ${name}(${a})${RESET}`);
 }
 export function toolResult(name, ok, output) {
+    if (QUIET)
+        return;
     const preview = output.split("\n")[0]?.slice(0, 120) ?? "";
     const icon = ok ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
     console.log(`${icon} ${CYAN}${name}${RESET} ${DIM}→${RESET} ${preview}`);
 }
 export function buildStatus(success, output) {
+    if (QUIET)
+        return;
     const icon = success ? `${GREEN}✓ BUILD SUCCESS` : `${RED}✗ BUILD FAILED`;
     console.log(`\n${icon}${RESET}\n${output.split("\n").slice(-10).join("\n")}\n`);
 }
 export function header(msg) {
+    if (QUIET)
+        return;
     console.log(`\n${BOLD}${CYAN}── ${msg} ${"─".repeat(Math.max(2, 60 - msg.length))}${RESET}`);
 }
 /** Startup banner: a clean key/value box (plain-text fallback when piped). */
 export function banner(title, rows) {
+    if (QUIET)
+        return;
     const keyWidth = Math.max(8, ...rows.map(([k]) => k.length));
     const inner = Math.max(title.length + 4, ...rows.map(([, v]) => keyWidth + Math.max(...String(v).split("\n").map((l) => l.length)) + 1));
     console.log(`${BOLD}${CYAN}╭─ ${title} ${"─".repeat(Math.max(1, inner - title.length - 3))}╮${RESET}`);
@@ -73,6 +103,8 @@ let _streamColor = CYAN;
 let _streamPrefix = "";
 /** Start a streaming line. Call llmStreamChunk() for each delta, then llmStreamEnd(). */
 export function llmStreamStart(prefix = "assistant", color = CYAN) {
+    if (QUIET)
+        return;
     _streamLine = "";
     _streamColor = color;
     _streamPrefix = prefix;
@@ -80,11 +112,15 @@ export function llmStreamStart(prefix = "assistant", color = CYAN) {
 }
 /** Append a text delta to the current streaming line. */
 export function llmStreamChunk(delta) {
+    if (QUIET)
+        return;
     _streamLine += delta;
     process.stdout.write(delta);
 }
 /** Finish the streaming line (append suffix + newline). */
 export function llmStreamEnd(suffix = "") {
+    if (QUIET)
+        return "";
     const line = _streamLine;
     _streamLine = "";
     process.stdout.write(`${suffix}\n`);
@@ -97,7 +133,7 @@ let _toolStreamLineOpen = false; // last chunk did not end with "\n"
 let _toolStreamChars = 0;
 /** Begin a live tool-output block. Output is printed dimmed, capped at 20k chars. */
 export function toolStreamStart() {
-    if (_toolStreamOpen)
+    if (QUIET || _toolStreamOpen)
         return;
     _toolStreamOpen = true;
     _toolStreamLineOpen = false;
@@ -106,7 +142,7 @@ export function toolStreamStart() {
 }
 /** Append a tool-output delta to the live block. */
 export function toolStreamChunk(delta) {
-    if (!_toolStreamOpen)
+    if (QUIET || !_toolStreamOpen)
         return;
     if (_toolStreamChars >= TOOL_STREAM_MAX_CHARS)
         return;
@@ -126,7 +162,7 @@ export function toolStreamChunk(delta) {
 }
 /** Finish the live tool-output block (closes the partial last line). */
 export function toolStreamEnd() {
-    if (!_toolStreamOpen)
+    if (QUIET || !_toolStreamOpen)
         return;
     _toolStreamOpen = false;
     process.stdout.write(_toolStreamLineOpen ? `\n${DIM}└${RESET}\n` : `${DIM}└${RESET}\n`);
@@ -138,6 +174,8 @@ export function isToolStreamOpen() {
 // ── Diff rendering ───────────────────────────────────────────────────────────
 /** Print a unified diff with colors (+ green, - red, @@ cyan). */
 export function printDiff(diffText) {
+    if (QUIET)
+        return;
     for (const line of diffText.split("\n")) {
         if (line.startsWith("+++") || line.startsWith("---")) {
             console.log(`${BOLD}${line}${RESET}`);
@@ -158,5 +196,7 @@ export function printDiff(diffText) {
 }
 /** Print a one-line diff summary: "✎ +12 -3 lines → src/foo.ts". */
 export function diffSummary(path, added, removed) {
+    if (QUIET)
+        return;
     console.log(`${CYAN}✎${RESET} ${BOLD}${path}${RESET} ${GREEN}+${added}${RESET} ${RED}-${removed}${RESET} lines`);
 }