s-app-scoder-agent 0.5.0 → 0.6.0

package/README.md

@@ -50,14 +50,17 @@ npx app-scoder-agent "your task"
 ## Quick Start
 
 ```bash
-# Set your API key
+# One-time setup wizard — writes .scoderrc.json (base URL, key, model, build cmd)
+scoder init
+
+# …or set your API key manually
 export SCODER_API_KEY=sk-...          # any OpenAI-compatible key (OpenAI, Groq, OpenRouter, Ollama, …)
 export OPENAI_BASE_URL=https://api.openai.com/v1  # optional, for custom endpoints
 
 # Run a task
 scoder "add a ping function to src/network.ts"
 
-# Interactive REPL
+# Interactive REPL (supports /help, /clear, /cost, /model)
 scoder
 ```
 
@@ -248,6 +251,28 @@ scoder streams everything it can, live, as it happens:
 - **SIGINT-safe** — Ctrl+C kills the running command immediately; streamed rendering never blocks the event loop.
 - Output honors `NO_COLOR` and degrades to plain text when piped (CI-friendly).
 
+## Full-Screen TUI (`scoder tui`)
+
+**Mission Control for the build loop** — a terminal UI built with [Ink](https://github.com/vadimdemedes/ink) (React for terminals), driven by the same `AgentEvent` stream the HTTP API exposes:
+
+```bash
+scoder tui                     # start an interactive full-screen session
+scoder tui "fix the bug"       # auto-submit an initial task
+```
+
+Features:
+
+- **Build Rail** (top bar) — brand, build lamp (`● build ok` / `● build fail` / `no build yet`), permission mode, and a step fuel gauge (`▰▰▰▱▱▱▱▱▱▱`) that fills as the agent burns through its step budget
+- **Chat pane** — your messages, streaming assistant text, and every tool call with live stdout/stderr preview (`✔/✘` status, spinner while running), prefixed with a flight-recorder step number (`03▸`)
+- **Diff cards** (`✎`) — every file write/edit renders as a unified diff (`+` green / `-` red / `@@` cyan hunk headers); the same diff also flows out of the HTTP SSE stream
+- **Status bar** — model, token usage (input/output/cached), keybind hints
+- **Slash commands** — `/help`, `/clear`, `/cost`, `/model`, `/exit` (identical to the REPL)
+- **Multi-turn** — keep typing follow-ups after a task finishes; the conversation context carries over (same as the REPL)
+- **Scrollback** — `PgUp`/`PgDn` page through history; `Esc` returns to the live tail (press again to abort)
+- **Keybinds** — `Enter` send · `PgUp`/`PgDn` scroll · `Esc` reset scroll / abort · `Ctrl+C` quit
+- Non-TTY environments (CI, pipes) automatically fall back to the classic REPL
+- `permission: "ask"` is not supported in the TUI (no readline prompts on the alt screen) — it falls back to `auto`
+
 ## HTTP Server Mode (`scoder serve`)
 
 Run scoder as a local HTTP service — submit tasks programmatically and consume progress as Server-Sent Events:
@@ -316,6 +341,8 @@ scoder detects the build command automatically:
 ```
 scoder [options] "<task>"     Run a task autonomously until the build passes
 scoder                       Start interactive session
+scoder init                  Setup wizard — writes .scoderrc.json (+ connection test)
+scoder tui [task]            Full-screen terminal UI (Mission Control)
 scoder serve [--port] [--host]   HTTP server mode (see above)
 scoder --help | --version     Help and version
 ```
@@ -373,30 +400,34 @@ scoder "upgrade express to v5 — check the official migration guide first"
 ```
 ┌─────────────────────────────────────────────┐
 │  CLI (src/index.ts)                         │
-│   arg parsing, REPL, serve, SIGINT          │
-└───────────────┬─────────────────────────────┘
-                │
-┌───────────────▼─────────────────────────────┐
-│  Agent (src/agent.ts)                       │
-│  Closed-loop orchestrator                   │
-│  history trimming, error injection          │
-│  emits AgentEvent (UI / SSE consumers)      │
-└──────┬─────────────┬───────────────┬────────┘
-       │             │               │
-┌──────▼───────┐  ┌──▼───────────┐  ┌▼──────────────────┐
-│  LLM Client  │  │ Tool Registry│  │ Server            │
-│ (src/llm.ts) │  │(src/tools.ts)│  │ (src/server.ts)   │
-│ OpenAI compat│  │ + web_fetch  │  │ HTTP API + SSE    │
-│ (anthropic:  │  │ (src/        │  │ runs in background│
-│  provider-   │  │  webfetch.ts)│  └───────────────────┘
-│  anthropic)  │  └──────────────┘
-└──────────────┘
-       │
-       ▼
-┌─────────────────────────────────────────────┐
-│  Build Checker (src/build.ts)               │
-│   run build → exit 0 = stop condition met   │
-└─────────────────────────────────────────────┘
+│   arg parsing, REPL, serve, tui, SIGINT     │
+└───────┬─────────────────────┬───────────────┘
+        │                     │
+┌───────▼───────────┐  ┌──────▼─────────────────────┐
+│  TUI (src/tui/)   │  │  Agent (src/agent.ts)      │
+│  Ink/React full-  │  │  Closed-loop orchestrator  │
+│  screen chat UI,  │─▶│  history trimming, error   │
+│  renders the same │  │  injection                 │
+│  AgentEvent stream│  │  emits AgentEvent          │
+└───────────────────┘  └──┬──────────┬──────────────┘
+                          │          │
+                          │          └────────────────────┐
+                          ▼                               ▼
+┌───────────────────────────────┐   ┌──────────────────────────┐
+│  LLM Client (src/llm.ts)      │   │  Server (src/server.ts)  │
+│  OpenAI-compatible + native   │   │  HTTP API + SSE          │
+│  Anthropic provider           │   │  runs in background      │
+└──────────────┬────────────────┘   └──────────────────────────┘
+               ▼
+┌────────────────────────────────────────┐
+│  Tool Registry (src/tools.ts)          │
+│  + web_fetch (src/webfetch.ts)         │
+└──────────────┬─────────────────────────┘
+               ▼
+┌───────────────────────────────┐
+│  Build Checker (src/build.ts) │
+│  run build → exit 0 = stop    │
+└───────────────────────────────┘
 ```
 
 ## Integration Testing
@@ -413,12 +444,14 @@ Test suites (run with `npm test` — auto-discovers `test/*.test.mjs`):
 - `test/tools.test.mjs` — safePath traversal, symlink escape, file-size cap, write/edit/list, live `run_command` output streaming
 - `test/webfetch.test.mjs` — HTML→text, JSON, redirects, SSRF guard, binary refusal, truncation
 - `test/server.test.mjs` — HTTP API: run lifecycle via SSE, abort, auth, live `tool_output` events
+- `test/tui.test.mjs` — full-screen TUI in a real PTY (via `test/pty-run.py`): closed loop render + slash commands (`/help`, `/cost`) + clean exit
+- `test/tui-state.test.mjs` — event reducer unit tests: diff items, build lamp, abort marking, slash-command parsing & help formatting
 - `test/core.test.mjs` — unified diff, retry backoff, context trimming
 - `test/config.test.mjs` — env/rc/cli precedence, logFile mapping, permission lists
 - `test/session.test.mjs` — session store, smart prune, resolve
 - `test/cost.test.mjs` — token usage & cost aggregation
 - `test/anthropic.test.mjs` — message translation + native SSE streaming
-- `test/llm.test.mjs` — OpenAI-compatible chat + SSE streaming + redaction
+- `test/llm.test.mjs` — OpenAI-compatible chat + SSE streaming + redaction + wire-format normalization
 - `test/run-e2e.mjs` — closed-loop integration (mock LLM server)
 - `test/run-mcp-test.mjs` — MCP smoke (mock stdio server)
 

package/dist/agent.js

@@ -148,6 +148,10 @@ export class Agent {
      * Record usage of one LLM call: render token counts, log an `llm_usage`
      * event, and accumulate totals into session state.
      */
+    /** Token usage totals accumulated in this session (for REPL `/cost`). */
+    getUsage() {
+        return { ...this.usageTotals };
+    }
     recordLlmUsage(usage) {
         if (!usage)
             return;
@@ -482,7 +486,14 @@ export class Agent {
                 this.endToolStream();
                 this.currentToolCall = null;
                 ui.toolResult(tc.name, result.ok, result.output);
-                this.emit({ type: "tool_result", step: steps, name: tc.name, ok: result.ok, output: result.output });
+                this.emit({
+                    type: "tool_result",
+                    step: steps,
+                    name: tc.name,
+                    ok: result.ok,
+                    output: result.output,
+                    ...(result.diff ? { diff: result.diff } : {}),
+                });
                 stepToolResults.set(tc.id, { ok: result.ok, output: result.output });
                 this.pushToolResult(tc, summariseOutput(result.output));
             }

package/dist/index.js

@@ -8,6 +8,7 @@ import { listSessions, resolveSessionId, pruneSessions } from "./session.js";
 import { JsonlLogger } from "./logger.js";
 import { collectUsage, formatCostReport } from "./cost.js";
 import { getVersion as getPackageVersion } from "./version.js";
+import { formatSlashHelp, parseSlashCommand } from "./tui/commands.js";
 import * as ui from "./ui.js";
 // Single source of truth: read version from package.json (see src/version.ts).
 const VERSION = getPackageVersion();
@@ -16,6 +17,8 @@ const HELP = `scoder — autonomous coding agent CLI
 USAGE
   scoder [options] "<task>"        Run a task autonomously until the build passes
   scoder                           Start interactive session (chat + tools)
+  scoder tui [task]                Full-screen terminal UI (chat pane, live tool feed)
+  scoder init                      First-run wizard: writes .scoderrc.json + tests the connection
   scoder list                      List saved sessions for this directory
   scoder resume <id|last> [task]   Resume a saved session (optionally with a follow-up task)
   scoder logs [id|last] [filter]   Print a session's JSONL log (requires --log-file runs)
@@ -173,6 +176,15 @@ function parseArgs(argv) {
         args.subcommand = "serve";
         args.task = null;
     }
+    else if (rest[0] === "tui") {
+        // scoder tui [initial-task] — full-screen Ink interface
+        args.subcommand = "tui";
+        args.task = rest.length > 1 ? rest.slice(1).join(" ") : null;
+    }
+    else if (rest[0] === "init") {
+        args.subcommand = "init";
+        args.task = null;
+    }
     return args;
 }
 async function runOnce(cfg, task) {
@@ -193,13 +205,79 @@ async function runOnce(cfg, task) {
         return 2;
     }
 }
+/**
+ * `scoder init` — first-run wizard: asks for the essentials, writes
+ * .scoderrc.json, then offers a live connection test against the provider.
+ */
+export async function runInit() {
+    const { existsSync, writeFileSync } = await import("node:fs");
+    const rcPath = resolve(process.cwd(), ".scoderrc.json");
+    ui.banner("scoder init — configure this project", [
+        ["file", rcPath],
+        ["note", "answers are saved to .scoderrc.json (env vars still override)"],
+    ]);
+    if (existsSync(rcPath)) {
+        const rl0 = createInterface({ input: process.stdin, output: process.stdout });
+        const overwrite = await new Promise((res) => rl0.question(`.scoderrc.json already exists — overwrite? [y/N] `, res));
+        rl0.close();
+        if (!/^y(es)?$/i.test(overwrite.trim())) {
+            ui.info("kept the existing .scoderrc.json");
+            return;
+        }
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q, def) => new Promise((res) => rl.question(`${q}${def ? ` [${def}]` : ""}: `, (a) => res(a.trim() || def)));
+    const baseUrl = await ask("API base URL (OpenAI-compatible)", "https://api.openai.com/v1");
+    const apiKey = await ask("API key (SCODER_API_KEY/OPENAI_API_KEY also work at runtime)", "");
+    const model = await ask("Model", "gpt-4o-mini");
+    const buildCmd = await ask("Build command (empty = auto-detect)", "");
+    const permission = (await ask("Permission mode (auto | ask | readonly)", "auto")).toLowerCase();
+    rl.close();
+    const provider = /api\.anthropic\.com/.test(baseUrl) || /^claude-/i.test(model) ? "anthropic" : "openai";
+    const rc = {
+        model,
+        baseUrl,
+        provider,
+        ...(buildCmd ? { buildCmd } : {}),
+        permissions: { mode: ["auto", "ask", "readonly"].includes(permission) ? permission : "auto" },
+    };
+    writeFileSync(rcPath, JSON.stringify(rc, null, 2) + "\n");
+    ui.success(`wrote ${rcPath} (provider: ${provider})`);
+    const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+    const doTest = await new Promise((res) => rl2.question("Test the connection now? [Y/n] ", res));
+    rl2.close();
+    if (!/^y(es)?$/i.test(doTest.trim()) && doTest.trim() !== "") {
+        ui.info("skipped connection test");
+        return;
+    }
+    if (!apiKey) {
+        ui.warn("no API key provided — set SCODER_API_KEY/OPENAI_API_KEY before running tasks");
+        return;
+    }
+    ui.info(`connecting to ${baseUrl} (${provider}) …`);
+    try {
+        const { LlmClient } = await import("./llm.js");
+        const { AnthropicClient } = await import("./provider-anthropic.js");
+        const client = provider === "anthropic"
+            ? new AnthropicClient({ baseUrl, apiKey, model, maxTokens: 16, temperature: 0 })
+            : new LlmClient({ baseUrl, apiKey, model, maxTokens: 16, temperature: 0 });
+        const res = await client.chat([{ role: "user", content: "Reply with exactly: OK" }], []);
+        const reply = (res.message.content ?? "").trim();
+        ui.success(`connection OK — model replied: ${JSON.stringify(reply)}`);
+    }
+    catch (err) {
+        ui.error(`connection test failed: ${err.message}`);
+        process.exitCode = 2;
+    }
+}
 async function repl(cfg) {
     ui.header(`scoder interactive — model: ${cfg.model}`);
     ui.info('Type a task and press Enter. "exit" or Ctrl+D to quit.');
     const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "you> " });
     // One shared session for the whole REPL conversation (plan P0.5 §4):
     // every input is a follow-up turn, context carries over, saved continuously.
-    const agent = new Agent(cfg);
+    // /clear swaps in a fresh Agent (the /clear branch reassigns this).
+    let agent = new Agent(cfg);
     process.on("SIGINT", () => {
         ui.warn("\nSIGINT — aborting current task...");
         agent.abort();
@@ -212,6 +290,37 @@ async function repl(cfg) {
             continue;
         if (input === "exit" || input === "quit")
             break;
+        // Slash commands — handled by the UI, never sent to the LLM.
+        const slash = parseSlashCommand(input);
+        if (slash) {
+            if (slash.cmd === "/exit" || slash.cmd === "/quit")
+                break;
+            if (slash.cmd === "/help") {
+                console.log(formatSlashHelp("scoder"));
+                continue;
+            }
+            if (slash.cmd === "/clear") {
+                agent.abort();
+                agent = new Agent(cfg);
+                first = true;
+                ui.info("conversation cleared — context reset");
+                continue;
+            }
+            if (slash.cmd === "/cost") {
+                const u = agent.getUsage();
+                console.log(u.calls > 0
+                    ? `session usage: ${u.calls} LLM calls · tokens in ${u.inputTokens} / out ${u.outputTokens}` +
+                        (u.cachedTokens > 0 ? ` (+${u.cachedTokens} cached)` : "")
+                    : "no LLM calls yet in this session");
+                continue;
+            }
+            if (slash.cmd === "/model") {
+                console.log(`model: ${cfg.model} · provider: ${cfg.provider} · build: ${cfg.buildCmd ?? "auto-detect"}`);
+                continue;
+            }
+            ui.error(`unknown command ${slash.cmd} — try /help`);
+            continue;
+        }
         try {
             const result = first ? await agent.run(input) : await agent.runTurn(input);
             first = false;
@@ -256,6 +365,10 @@ async function main() {
         logFile: args.logFile,
     });
     // Subcommands
+    if (args.subcommand === "init") {
+        await runInit();
+        return;
+    }
     if (args.subcommand === "list") {
         const sessions = listSessions(cfg.workdir);
         if (sessions.length === 0) {
@@ -320,6 +433,19 @@ async function main() {
         console.log(formatCostReport(sessionCosts));
         return;
     }
+    if (args.subcommand === "tui") {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            ui.warn("TUI requires an interactive terminal (TTY) — falling back to the classic REPL.");
+            await repl(cfg);
+            return;
+        }
+        if (!cfg.apiKey) {
+            ui.warn("No API key configured — tasks will fail until SCODER_API_KEY (or OPENAI_API_KEY) is set.");
+        }
+        const { runTui } = await import("./tui/app.js");
+        await runTui(cfg, args.task);
+        return;
+    }
     if (args.subcommand === "serve") {
         const { startServer } = await import("./server.js");
         if (!cfg.apiKey) {

package/dist/llm.js

@@ -76,6 +76,29 @@ function parseSSELine(line) {
 // ---------------------------------------------------------------------------
 // LlmClient
 // ---------------------------------------------------------------------------
+/**
+ * Serialize conversation history to the OpenAI wire format. Internal ToolCall
+ * shape is `{id, name, arguments}`; the API expects
+ * `{id, type: "function", function: {name, arguments}}`. Some providers
+ * (Upstage/solar) reject assistant tool_calls in the internal shape with a
+ * misleading "Invalid function name: ''" error — always normalize here.
+ */
+function toWireMessages(messages) {
+    return messages.map((m) => {
+        if (m.role === "assistant" && m.tool_calls) {
+            return {
+                role: m.role,
+                content: m.content,
+                tool_calls: m.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.arguments },
+                })),
+            };
+        }
+        return m;
+    });
+}
 export class LlmClient {
     opts;
     streamEnabled;
@@ -92,7 +115,7 @@ export class LlmClient {
         const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
         const body = JSON.stringify({
             model: this.opts.model,
-            messages,
+            messages: toWireMessages(messages),
             tools: tools.length > 0 ? tools : undefined,
             temperature: this.opts.temperature,
             max_tokens: this.opts.maxTokens,
@@ -153,7 +176,7 @@ export class LlmClient {
         const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
         const bodyStr = JSON.stringify({
             model: this.opts.model,
-            messages,
+            messages: toWireMessages(messages),
             tools: tools.length > 0 ? tools : undefined,
             temperature: this.opts.temperature,
             max_tokens: this.opts.maxTokens,

package/dist/tools.js

@@ -89,16 +89,21 @@ function toolReadFile(workdir, args) {
         return { ok: true, output: clamp(numbered) };
     });
 }
+function toToolDiff(path, diff) {
+    if (!diff.text && !diff.truncated)
+        return undefined;
+    return { path, text: diff.text, added: diff.added, removed: diff.removed, truncated: diff.truncated };
+}
 /** Shared permission/diff gate for file writes. Returns null = approved. */
-async function gateWrite(ctx, path, oldContent, newContent) {
+async function gateWrite(ctx, path, diff) {
     const mode = ctx.permissionMode ?? "auto";
-    const diff = unifiedDiff(path, oldContent, newContent);
     if (mode === "readonly") {
         if (diff.text)
             ui.printDiff(diff.text);
         return {
             ok: false,
             output: `ERROR: readonly mode — write to ${path} denied. The diff above is shown for review only; nothing was written.`,
+            diff: toToolDiff(path, diff),
         };
     }
     if (mode === "ask" && ctx.permissions) {
@@ -106,7 +111,11 @@ async function gateWrite(ctx, path, oldContent, newContent) {
             ui.printDiff(diff.text);
         const allowed = await ctx.permissions.confirmEdit(path, diff.text);
         if (!allowed) {
-            return { ok: false, output: `ERROR: user rejected the write to ${path}. Try a different approach or explain why it is needed.` };
+            return {
+                ok: false,
+                output: `ERROR: user rejected the write to ${path}. Try a different approach or explain why it is needed.`,
+                diff: toToolDiff(path, diff),
+            };
         }
     }
     else if (diff.text && !diff.truncated) {
@@ -132,12 +141,17 @@ async function toolWriteFile(ctx, args) {
     catch {
         // new file
     }
-    const gate = await gateWrite(ctx, args.path, oldContent, args.content);
+    const diff = unifiedDiff(args.path, oldContent, args.content);
+    const gate = await gateWrite(ctx, args.path, diff);
     if (gate)
         return gate;
     mkdirSync(dirname(abs), { recursive: true });
     writeFileSync(abs, args.content, "utf8");
-    return { ok: true, output: `Wrote ${args.content.split("\n").length} lines to ${args.path}` };
+    return {
+        ok: true,
+        output: `Wrote ${args.content.split("\n").length} lines to ${args.path}`,
+        diff: toToolDiff(args.path, diff),
+    };
 }
 async function toolEditFile(ctx, args) {
     let abs;
@@ -158,11 +172,16 @@ async function toolEditFile(ctx, args) {
     // Function replacement: avoids JS $-pattern interpolation ($&, $', $`, $1…)
     // which would corrupt literal text like "$&" in the new content.
     const newContent = content.replace(args.old_string, () => args.new_string);
-    const gate = await gateWrite(ctx, args.path, content, newContent);
+    const diff = unifiedDiff(args.path, content, newContent);
+    const gate = await gateWrite(ctx, args.path, diff);
     if (gate)
         return gate;
     writeFileSync(abs, newContent, "utf8");
-    return { ok: true, output: `Edited ${args.path}` };
+    return {
+        ok: true,
+        output: `Edited ${args.path}`,
+        diff: toToolDiff(args.path, diff),
+    };
 }
 function toolListFiles(workdir, args) {
     return toResult(() => {

package/dist/tui/app.js

@@ -0,0 +1,315 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Full-screen Ink TUI for scoder — "mission control for the build loop".
+ *
+ * Identity (deliberately distinct from chat-first agent UIs): the build is
+ * the mission, so the screen is organized around it —
+ *   · Build Rail (top): brand, build-status lamp, step fuel gauge ▰▰▰▱▱▱
+ *   · Flight-recorder log: each tool entry is stamped `07 ▸ name(args)`
+ *   · `✎` diff cards rendered inline for every file edit
+ * Driven entirely by AgentEvents (the same stream the HTTP/SSE server uses).
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { Agent } from "../agent.js";
+import { setQuiet } from "../ui.js";
+import { applyEvent, initialState, markAborted } from "./state.js";
+import { formatSlashHelp, parseSlashCommand } from "./commands.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Fuel gauge is scaled to this many cells regardless of maxSteps. */
+const GAUGE_CELLS = 10;
+function useSpinner(active) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        if (!active)
+            return;
+        const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+        return () => clearInterval(timer);
+    }, [active]);
+    return SPINNER_FRAMES[frame];
+}
+function formatArgs(args) {
+    return Object.entries(args)
+        .map(([k, v]) => {
+        const s = typeof v === "string" ? v : JSON.stringify(v) ?? "";
+        return `${k}=${s.length > 60 ? s.slice(0, 60) + "…" : s.replace(/\n/g, " ")}`;
+    })
+        .join(" ");
+}
+/** Scaled step fuel gauge: ▰ filled / ▱ remaining, e.g. ▰▰▰▰▱▱▱▱ 4/40. */
+function fuelGauge(step, maxSteps) {
+    if (maxSteps <= 0)
+        return null;
+    const filled = Math.min(GAUGE_CELLS, Math.round((Math.min(step, maxSteps) / maxSteps) * GAUGE_CELLS));
+    return "▰".repeat(filled) + "▱".repeat(GAUGE_CELLS - filled);
+}
+const OUTPUT_PREVIEW_LINES = 4;
+function ToolItemView({ item, spinner }) {
+    const running = item.ok === null;
+    const icon = running ? _jsx(Text, { color: "cyan", children: spinner }) : item.ok ? _jsx(Text, { color: "green", children: "\u2714" }) : _jsx(Text, { color: "red", children: "\u2718" });
+    const lines = item.output.length > 0 ? item.output.replace(/\n+$/, "").split("\n") : [];
+    const preview = lines.slice(-OUTPUT_PREVIEW_LINES);
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [String(item.step).padStart(2, "0"), "\u25B8"] }), " ", icon, " ", _jsx(Text, { color: "cyan", children: item.name }), _jsxs(Text, { dimColor: true, children: ["(", formatArgs(item.args), ")"] }), running && _jsx(Text, { dimColor: true, children: " \u00B7 running\u2026" })] }), preview.map((line, i) => (_jsx(Text, { dimColor: i < preview.length - 1, children: line.length > 160 ? line.slice(0, 160) + "…" : line }, i)))] }));
+}
+/** One colored line of a unified diff (+ green, - red, @@ cyan, header bold). */
+function DiffLine({ line }) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+        return _jsx(Text, { bold: true, children: line });
+    if (line.startsWith("@@"))
+        return _jsx(Text, { color: "cyan", children: line });
+    if (line.startsWith("+"))
+        return _jsx(Text, { color: "green", children: line });
+    if (line.startsWith("-"))
+        return _jsx(Text, { color: "red", children: line });
+    return _jsx(Text, { children: line });
+}
+const MAX_DIFF_RENDER_LINES = 24;
+function DiffItemView({ item }) {
+    const lines = item.text.length > 0 ? item.text.split("\n") : [];
+    const shown = lines.slice(0, MAX_DIFF_RENDER_LINES);
+    const hidden = lines.length - shown.length;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [String(item.step).padStart(2, "0"), "\u25B8"] }), " ", _jsx(Text, { color: "magenta", bold: true, children: "\u270E" }), " ", _jsxs(Text, { color: "green", children: ["+", item.added] }), " ", _jsxs(Text, { color: "red", children: ["-", item.removed] }), " ", _jsx(Text, { bold: true, children: item.path }), item.truncated && _jsx(Text, { color: "yellow", children: " (diff truncated)" })] }), shown.map((line, i) => (_jsx(DiffLine, { line: line.length > 160 ? line.slice(0, 160) + "…" : line }, i))), hidden > 0 && _jsxs(Text, { dimColor: true, children: ["\u2026 +", hidden, " more diff lines"] })] }));
+}
+function ChatItemView({ item, spinner }) {
+    switch (item.kind) {
+        case "user":
+            return (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "blue", bold: true, children: ["\u276F", " "] }), _jsx(Text, { bold: true, children: item.text })] }));
+        case "assistant":
+            return (_jsx(Box, { marginTop: item.text ? 1 : 0, paddingLeft: 1, children: _jsx(Text, { dimColor: item.streaming, children: item.text || (item.streaming ? "" : "(no text)") }) }));
+        case "tool":
+            return _jsx(ToolItemView, { item: item, spinner: spinner });
+        case "diff":
+            return _jsx(DiffItemView, { item: item });
+        case "build":
+            return (_jsxs(Box, { paddingLeft: 1, children: [item.success ? _jsx(Text, { color: "green", bold: true, children: "\u2714 build passed" }) : _jsx(Text, { color: "red", bold: true, children: "\u2718 build failed" }), _jsxs(Text, { dimColor: true, children: [" \u2014 ", item.command] })] }));
+        case "notice":
+            return (_jsx(Box, { paddingLeft: 1, children: _jsxs(Text, { color: item.level === "error" ? "red" : item.level === "warn" ? "yellow" : "gray", children: [item.level === "error" ? "✘ " : "⚠ ", item.text.length > 500 ? item.text.slice(0, 500) + "…" : item.text] }) }));
+    }
+}
+/** Build Rail — scoder's signature top bar: lamp + build command + fuel gauge. */
+function BuildRail({ state, config }) {
+    const lampColor = state.buildLamp === "ok" ? "green" : state.buildLamp === "fail" ? "red" : "gray";
+    const lampLabel = state.buildLamp === "ok" ? "build ok" : state.buildLamp === "fail" ? "build fail" : "no build yet";
+    const gauge = fuelGauge(state.step, state.maxSteps);
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "magenta", children: "scoder" }), _jsxs(Text, { children: [_jsxs(Text, { color: lampColor, children: ["\u25CF ", lampLabel] }), _jsxs(Text, { dimColor: true, children: [" ", state.buildCmd || config.buildCmd || "auto"] })] }), _jsxs(Text, { children: [gauge && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "magenta", children: gauge }), _jsxs(Text, { dimColor: true, children: [" ", state.step, "/", state.maxSteps] })] })), !gauge && _jsx(Text, { dimColor: true, children: "\u2014 idle" })] })] }));
+}
+function StatusBar({ state, spinner }) {
+    const statusColor = state.status === "running" ? "cyan" : state.status === "success" ? "green" : state.status === "failed" ? "red" : "gray";
+    const statusLabel = state.status === "running" ? `running ${state.step}/${state.maxSteps}` : state.status === "idle" ? "idle" : state.status;
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { color: statusColor, children: state.status === "running" ? `${spinner} ${statusLabel}` : statusLabel }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", state.model || "—"] }), state.usage.calls > 0 && (_jsxs(Text, { dimColor: true, children: [" ", "\u00B7 tok ", state.usage.inputTokens, "/", state.usage.outputTokens, state.usage.cachedTokens > 0 ? ` (+${state.usage.cachedTokens} cached)` : ""] }))] }), _jsx(Text, { dimColor: true, children: "\u23CE send \u00B7 pgup/pgdn scroll \u00B7 esc abort \u00B7 ctrl+c quit" })] }));
+}
+function Input({ valueRef, value, onChange, onSubmit }) {
+    useInput((input, key) => {
+        const current = valueRef.current;
+        if (key.return) {
+            onSubmit(current);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            const next = current.slice(0, -1);
+            valueRef.current = next;
+            onChange(next);
+            return;
+        }
+        if (input.length > 0 && !key.ctrl && !key.meta && !key.escape && !key.upArrow && !key.downArrow && !key.tab) {
+            // A chunk may contain several pasted chars — even a trailing newline
+            // (terminal pastes / PTY writes deliver "exit\r" as one chunk).
+            const parts = input.split(/[\r\n]+/);
+            const next = current + parts[0];
+            valueRef.current = next;
+            onChange(next);
+            if (parts.length > 1)
+                onSubmit(next); // newline in the chunk = submit
+        }
+    });
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "❯ " }), _jsx(Text, { children: value }), _jsx(Text, { dimColor: true, children: "\u258C" })] }));
+}
+export function TuiApp({ config, initialTask, bootNotice }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [state, setState] = useState(initialState);
+    const [input, setInput] = useState(initialTask ?? "");
+    const [scrollOffset, setScrollOffset] = useState(0); // 0 = pinned to bottom
+    const inputRef = useRef(initialTask ?? "");
+    const writeInput = useCallback((v) => {
+        inputRef.current = v;
+        setInput(v);
+    }, []);
+    const runningRef = useRef(false);
+    const agentRef = useRef(null);
+    const spinner = useSpinner(state.status === "running");
+    // Boot notice (e.g. "permission=ask is not supported in the TUI") as a chat
+    // item, so it scrolls with the conversation instead of being lost off-screen.
+    const bootedRef = useRef(false);
+    useEffect(() => {
+        if (bootedRef.current)
+            return;
+        bootedRef.current = true;
+        if (bootNotice)
+            setState((s) => ({ ...s, items: [{ kind: "notice", text: bootNotice, level: "warn" }, ...s.items] }));
+    }, [bootNotice]);
+    const pushNotice = useCallback((text, level = "info") => setState((s) => ({ ...s, items: [...s.items, { kind: "notice", text, level }] })), []);
+    const submit = useCallback(async (text) => {
+        const task = text.trim();
+        if (!task)
+            return;
+        // "exit"/"quit" always works — aborts a running agent first.
+        if (task === "exit" || task === "quit") {
+            agentRef.current?.abort();
+            exit();
+            return;
+        }
+        // Slash commands — handled by the UI itself, never sent to the LLM.
+        const slash = parseSlashCommand(task);
+        if (slash) {
+            writeInput("");
+            if (slash.cmd === "/exit" || slash.cmd === "/quit") {
+                agentRef.current?.abort();
+                exit();
+                return;
+            }
+            if (slash.cmd === "/help") {
+                pushNotice(formatSlashHelp("scoder tui"));
+                return;
+            }
+            if (slash.cmd === "/clear") {
+                agentRef.current?.abort();
+                agentRef.current = null;
+                runningRef.current = false;
+                writeInput("");
+                setScrollOffset(0);
+                setState(initialState());
+                return;
+            }
+            if (slash.cmd === "/cost") {
+                const u = stateRef.current.usage;
+                pushNotice(u.calls > 0
+                    ? `session usage: ${u.calls} LLM calls · tokens in ${u.inputTokens} / out ${u.outputTokens}` +
+                        (u.cachedTokens > 0 ? ` (+${u.cachedTokens} cached)` : "")
+                    : "no LLM calls yet in this session");
+                return;
+            }
+            if (slash.cmd === "/model") {
+                const s = stateRef.current;
+                pushNotice(`model: ${s.model || config.model || "—"} · provider: ${s.provider || config.provider || "auto"}`);
+                return;
+            }
+            pushNotice(`unknown command ${slash.cmd} — try /help`, "warn");
+            return;
+        }
+        if (runningRef.current)
+            return; // keep the typed text for when the agent is idle
+        writeInput("");
+        runningRef.current = true;
+        setScrollOffset(0);
+        // isFirst must be computed BEFORE pushing the user item below.
+        const isFirst = stateRef.current.items.every((i) => i.kind !== "user");
+        // runTurn() doesn't emit run_start, so the TUI shows the user's message
+        // itself; applyEvent's run_start dedupe keeps turn 1 from doubling.
+        setState((s) => ({ ...s, items: [...s.items, { kind: "user", text: task }], status: "running", summary: null }));
+        let agent = agentRef.current;
+        if (!agent) {
+            agent = new Agent(config);
+            // Functional updates: React feeds each updater the latest queued
+            // state, so events can never land on a stale snapshot (a ref mirror
+            // updated in useEffect races events arriving within one render batch
+            // — tool results then miss their items and stay "running…" forever).
+            agent.onEvent = (ev) => setState((prev) => {
+                const next = applyEvent(prev, ev);
+                return { ...next, items: [...next.items] };
+            });
+            agentRef.current = agent;
+        }
+        try {
+            // First submission runs the full closed loop; later ones continue the session.
+            const result = isFirst ? await agent.run(task) : await agent.runTurn(task);
+            void result;
+            runningRef.current = false;
+        }
+        catch (err) {
+            runningRef.current = false;
+            setState((s) => applyEvent({ ...s, items: [...s.items] }, { type: "error", message: err.message }));
+        }
+    }, [config, pushNotice, writeInput, exit]);
+    // Mirror of state for the submit path (isFirst, /cost, /model) and the
+    // abort handler — approximate between renders, exact whenever idle.
+    const stateRef = useRef(state);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    // Esc aborts the running task (like SIGINT in the CLI); when scrolled up,
+    // the first Esc returns to the bottom instead.
+    const scrollOffsetRef = useRef(0);
+    useEffect(() => {
+        scrollOffsetRef.current = scrollOffset;
+    }, [scrollOffset]);
+    useInput((_input, key) => {
+        if (key.pageUp)
+            setScrollOffset((o) => Math.min(stateRef.current.items.length, o + 10));
+        if (key.pageDown)
+            setScrollOffset((o) => Math.max(0, o - 10));
+        if (key.escape) {
+            if (scrollOffsetRef.current > 0) {
+                setScrollOffset(0);
+                return;
+            }
+            if (runningRef.current) {
+                setState((s) => ({ ...markAborted(s), items: [...s.items] }));
+                agentRef.current?.abort();
+            }
+        }
+    });
+    // Ctrl+C quits (press again within 2s to confirm while running).
+    const ctrlCArmed = useRef(null);
+    useInput((_input, key) => {
+        if (!key.ctrl || _input !== "c")
+            return;
+        if (runningRef.current && ctrlCArmed.current === null) {
+            ctrlCArmed.current = Date.now();
+            setState((s) => ({ ...s, items: [...s.items, { kind: "notice", text: "Press Ctrl+C again to quit", level: "warn" }] }));
+            setTimeout(() => (ctrlCArmed.current = null), 2000);
+            return;
+        }
+        agentRef.current?.abort();
+        exit();
+    });
+    // Submit an initial task passed on the command line once, after mount.
+    const bootRef = useRef(false);
+    useEffect(() => {
+        if (initialTask && !bootRef.current && input === initialTask) {
+            bootRef.current = true;
+            void submit(initialTask);
+        }
+    }, [initialTask, input, submit]);
+    const lastSummary = useMemo(() => {
+        if (state.status === "running" || state.status === "idle")
+            return null;
+        return state.summary;
+    }, [state.status, state.summary]);
+    // Scrollback viewport: by default pin to the newest items that fit on
+    // screen; PgUp/PgDn moves the window over the flight-recorder log.
+    const rows = stdout.rows ?? 24;
+    const viewItems = Math.max(6, rows - 9);
+    const total = state.items.length;
+    const start = Math.max(0, Math.min(total - viewItems, total - viewItems - scrollOffset));
+    const end = Math.max(start, Math.min(total, total - scrollOffset));
+    const visible = state.items.slice(start, end);
+    return (_jsxs(Box, { flexDirection: "column", height: "100%", children: [_jsx(BuildRail, { state: state, config: config }), _jsxs(Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [total === 0 && (_jsx(Text, { dimColor: true, children: "Type a task and press Enter. The agent works autonomously until the build passes. (/help for commands)" })), scrollOffset > 0 && _jsx(Text, { dimColor: true, children: "\u2191 scrollback \u2014 PgDn to return to the newest" }), visible.map((item, i) => (_jsx(ChatItemView, { item: item, spinner: spinner }, start + i))), state.status === "running" && state.step > 0 && (_jsxs(Text, { dimColor: true, children: [spinner, " step ", state.step, "/", state.maxSteps, " \u2014 thinking\u2026"] })), lastSummary && (_jsx(Box, { marginTop: 1, children: state.status === "success" ? (_jsxs(Text, { color: "green", bold: true, children: ["\u2714 ", lastSummary] })) : state.status === "aborted" ? (_jsxs(Text, { color: "yellow", bold: true, children: ["\u23F9 ", lastSummary] })) : (_jsxs(Text, { color: "red", bold: true, children: ["\u2718 ", lastSummary] })) }))] }), _jsx(Box, { paddingX: 1, children: _jsx(Input, { valueRef: inputRef, value: input, onChange: writeInput, onSubmit: (v) => void submit(v) }) }), _jsx(StatusBar, { state: state, spinner: spinner })] }));
+}
+/** Mount the TUI (called from the `scoder tui` subcommand). */
+export async function runTui(config, initialTask) {
+    setQuiet(true);
+    // `ask` prompts via readline on stdin, which corrupts the alt-screen TUI
+    // (same rule as `scoder serve`): fall back to auto with an in-pane notice.
+    let bootNotice = null;
+    if (config.permissionMode === "ask") {
+        config = { ...config, permissionMode: "auto" };
+        bootNotice = "permission=ask is not supported in the TUI — falling back to auto";
+    }
+    const { render } = await import("ink");
+    const { waitUntilExit } = render(_jsx(TuiApp, { config: config, initialTask: initialTask, bootNotice: bootNotice }));
+    await waitUntilExit();
+    // Ink restores the terminal on unmount; exit explicitly so provider
+    // keep-alive sockets (undici pool) can't keep the event loop alive.
+    process.exit(0);
+}

package/dist/tui/commands.js

@@ -0,0 +1,24 @@
+/**
+ * Slash commands shared by the classic REPL (src/index.ts) and the Ink TUI
+ * (src/tui/app.tsx). Pure parsing/formatting only — each frontend executes
+ * the command against its own context, so both stay in sync on the surface.
+ */
+export const SLASH_COMMANDS = [
+    { cmd: "/help", desc: "show this command list" },
+    { cmd: "/clear", desc: "clear the conversation and reset agent context" },
+    { cmd: "/cost", desc: "token usage of the current session" },
+    { cmd: "/model", desc: "show the active model & provider" },
+    { cmd: "/exit", desc: "quit (aliases: /quit, exit, quit)" },
+];
+/** Parse "/cmd arg…"; returns null when the input is not a slash command. */
+export function parseSlashCommand(input) {
+    const m = /^\/([a-zA-Z][a-zA-Z0-9]*)(?:\s+(.*\S))?\s*$/.exec(input.trim());
+    if (!m)
+        return null;
+    return { cmd: "/" + m[1].toLowerCase(), arg: m[2] ?? "" };
+}
+/** Format the /help listing (shared so both frontends render identically). */
+export function formatSlashHelp(commandName) {
+    const rows = SLASH_COMMANDS.map((c) => `  ${c.cmd.padEnd(8)} ${c.desc}`).join("\n");
+    return `Commands (${commandName}):\n${rows}\n  Anything else is sent to the agent as a task.`;
+}

package/dist/tui/state.js

@@ -0,0 +1,166 @@
+export function initialState() {
+    return {
+        items: [],
+        status: "idle",
+        step: 0,
+        maxSteps: 0,
+        model: "",
+        provider: "",
+        workdir: "",
+        buildCmd: "",
+        buildLamp: "none",
+        usage: { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 },
+        summary: null,
+    };
+}
+const MAX_ITEMS = 400;
+const MAX_OUTPUT_CHARS = 20_000;
+const MAX_TEXT_CHARS = 40_000;
+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)}`;
+}
+/**
+ * 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 "run_start": {
+            state.model = ev.model;
+            state.provider = ev.provider;
+            state.workdir = ev.workdir;
+            state.buildCmd = ev.buildCmd;
+            state.buildLamp = "none";
+            state.status = "running";
+            state.step = 0;
+            state.summary = null;
+            state.usage = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 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 "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;
+            break;
+        }
+        case "llm_delta": {
+            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, ok: null, output: "", step: ev.step });
+            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": {
+            for (let i = state.items.length - 1; i >= 0; i--) {
+                const it = state.items[i];
+                if (it.kind === "tool" && it.name === ev.name && it.ok === null) {
+                    it.ok = ev.ok;
+                    // Prefer the final (complete) result over accumulated live chunks.
+                    if (ev.output.length >= it.output.length)
+                        it.output = ev.output;
+                    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";
+            appendItem(state, { kind: "build", success: ev.success, command: ev.command });
+            break;
+        }
+        case "finish": {
+            state.status = ev.success ? "success" : /interrupted|aborted/i.test(ev.summary) ? "aborted" : "failed";
+            state.summary = ev.summary;
+            // Close any dangling streaming assistant message.
+            const last = lastItem(state);
+            if (last && last.kind === "assistant")
+                last.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…";
+    const last = lastItem(state);
+    if (last && last.kind === "assistant")
+        last.streaming = false;
+    return state;
+}

package/dist/tui-direct.mjs

@@ -0,0 +1,4 @@
+import { runTui } from "./tui/app.js";
+console.log("calling runTui");
+await runTui({ workdir: process.cwd(), model: "m", provider: "openai", apiKey: "k", permissionMode: "auto", baseUrl: "http://127.0.0.1:1", maxSteps: 5, stream: false }, null);
+console.log("returned");

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`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s-app-scoder-agent",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Autonomous coding agent CLI - similar to opencode/cline/claude. Runs tasks until build succeeds.",
   "type": "module",
   "main": "dist/index.js",
@@ -46,8 +46,13 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
+    "@types/react": "^18.3.31",
     "eslint": "^10.13.0",
     "typescript": "^5.6.0",
     "typescript-eslint": "^8.72.1"
+  },
+  "dependencies": {
+    "ink": "^5.2.1",
+    "react": "^18.3.1"
   }
 }