interference-agent 0.1.0 → 0.2.2

package/README.md

@@ -3,7 +3,7 @@
 <p align="center"><strong>The open-source coding agent that lives in your terminal.</strong></p>
 
 <p align="center">
-  TypeScript + Bun · Plan / Build modes · 9 tools · permissions · sessions with undo · 38 skills · subagents · TUI
+  TypeScript + Bun · Plan / Build modes · 11 tools · permissions · sessions with undo · extensible skills · subagents · TUI
 </p>
 
 ---
@@ -14,10 +14,10 @@ permissions and a read-only **Plan** mode so nothing happens without your say-so
 
 ## Features
 
-- **9 tools**: `read` · `ls` · `glob` · `grep` · `webfetch` · `write` · `edit` · `bash` · `task` (subagent)
+- **11 tools**: `read` · `ls` · `glob` · `grep` · `webfetch` · `write` · `edit` · `bash` · `todowrite` · `question` · `task` (subagent)
 - **Plan & Build** modes — explore read-only, switch to full access when ready
 - **Permissioned by design** — allow / ask / deny enforced in code, not in the prompt; dangerous commands auto-blocked (`rm -rf`, `sudo`, `curl | sh`)
-- **38 skills** — auto-detected by keyword matching, or invoked explicitly via `/skill-name`; full Agent Skills format support
+- **Extensible skills** — Agent Skills format (SKILL.md); auto-detected by keyword matching, or invoked via `/skill-name`; 3 skills bundled, user-extensible
 - **Subagents** — delegate complex tasks to isolated agents (`explore` for read-only, `general` for full access)
 - **Atomic edit** — unique-match string replacement with `replaceAll` support
 - **Safe bash** — timeout, output truncation, exit code, dangerous-command deny list
@@ -51,13 +51,34 @@ permissions and a read-only **Plan** mode so nothing happens without your say-so
 ## Quickstart
 
 ```bash
-bun install
-# Set API key in .env (Bun auto-loads it)
-echo 'DEEPSEEK_API_KEY=sk-...' > .env
-bun run interference
+bun install -g interference-agent
+interference
 ```
 
-> Requires **Bun 1.3+** (Node ≥22 / React ≥19.2 for the Ink TUI).
+On first run, use `/provider` to add your API keys. They're saved in `~/.interference/auth.json`.
+
+interference stores its state in `~/.interference/` — sessions, skills, snapshots, and auth — just like Claude Code uses `~/.claude/`.
+
+> Requires **Bun 1.3+**.
+
+## Updating
+
+```bash
+bun install -g interference-agent@latest   # or: npm i -g interference-agent@latest
+```
+
+interference checks npm for new versions and shows a discreet notice when one is available; run `/update` from inside the app to upgrade.
+
+## Releasing (maintainers)
+
+Releases publish to npm automatically on tag push:
+
+```bash
+npm version minor        # runs typecheck+test, bumps, tags
+git push --follow-tags   # the `publish` GitHub Action publishes to npm
+```
+
+Requires the `NPM_TOKEN` repo secret. See `CHANGELOG.md`.
 
 ## Screenshot
 

package/package.json

@@ -1,23 +1,42 @@
 {
   "name": "interference-agent",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "The open-source coding agent that lives in your terminal.",
   "type": "module",
   "license": "MIT",
   "author": "ricciviero",
   "repository": "github:ricciviero/interference",
   "homepage": "https://github.com/ricciviero/interference#readme",
-  "keywords": ["ai", "coding-agent", "terminal", "cli", "bun", "typescript", "llm", "open-source"],
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "terminal",
+    "cli",
+    "bun",
+    "typescript",
+    "llm",
+    "open-source"
+  ],
   "bin": {
     "interference": "./src/cli.ts"
   },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
   "scripts": {
     "interference": "bun run src/cli.ts",
     "start": "bun run src/cli.ts",
     "dev": "bun run --watch src/cli.ts",
     "typecheck": "bunx tsc --noEmit",
     "build": "bun build src/cli.ts --compile --minify --sourcemap --outfile dist/interference",
-    "test": "bun test ./src"
+    "test": "bun test ./src",
+    "preversion": "bun run typecheck && bun run test",
+    "postversion": "git push && git push --tags"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^4.0.1",

package/src/__tests__/version.test.ts

@@ -0,0 +1,24 @@
+import { describe, test, expect } from "bun:test";
+import { isNewer, CURRENT_VERSION } from "../version.ts";
+import { dispatch } from "../commands/index.ts";
+
+describe("version / update (iter 28)", () => {
+  test("isNewer compares semver correctly", () => {
+    expect(isNewer("0.2.0", "0.1.0")).toBe(true);
+    expect(isNewer("1.0.0", "0.9.9")).toBe(true);
+    expect(isNewer("0.1.1", "0.1.0")).toBe(true);
+    expect(isNewer("0.1.0", "0.1.0")).toBe(false);
+    expect(isNewer("0.1.0", "0.2.0")).toBe(false);
+    expect(isNewer("v0.3.0", "0.2.9")).toBe(true); // tollera prefisso v
+  });
+
+  test("CURRENT_VERSION matches package.json", async () => {
+    const pkg = await Bun.file(new URL("../../package.json", import.meta.url)).json();
+    expect(CURRENT_VERSION).toBe(pkg.version);
+  });
+
+  test("/version command returns the version", async () => {
+    const out = await dispatch("/version", {});
+    expect(out).toBe(`interference v${CURRENT_VERSION}`);
+  });
+});

package/src/cli-plain.ts

@@ -226,18 +226,18 @@ async function consumeTurn(chunks: AsyncGenerator<Chunk>): Promise<void> {
   for await (const chunk of chunks) {
     switch (chunk.type) {
       case "reasoning":
-        if (!sawReasoning) { stdout.write(`${DIM}┄ thinking${RESET}\n`); sawReasoning = true; }
+        if (!sawReasoning) { stdout.write(`${YELLOW}✻ Thinking${RESET}\n`); sawReasoning = true; }
         stdout.write(`${DIM}${chunk.text}${RESET}`);
         break;
       case "text":
         if (activeTool) { stdout.write("\n"); activeTool = null; }
-        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        if (sawReasoning && !inText) { stdout.write(`\n\n`); inText = true; }
         else if (!inText) { inText = true; }
         stdout.write(chunk.text);
         break;
       case "tool-call": {
         const args = typeof chunk.input === "string" ? chunk.input : JSON.stringify(chunk.input);
-        if (sawReasoning && !inText) { stdout.write(`\n${DIM}┄${RESET}\n\n`); inText = true; }
+        if (sawReasoning && !inText) { stdout.write(`\n\n`); inText = true; }
         else if (activeTool || !inText) { stdout.write("\n"); }
         stdout.write(`${DIM}· ${chunk.toolName}${RESET}(${args})`);
         activeTool = { name: chunk.toolName, args, input: chunk.input };

package/src/cli.ts

@@ -11,8 +11,16 @@ import { loadConfig, applyConfig } from "./config-file.ts";
 import { loadAuth, applyAuthToEnv } from "./auth.ts";
 import { PROVIDERS } from "./config.ts";
 import type { Session } from "./session/store.ts";
+import { CURRENT_VERSION } from "./version.ts";
 
 async function main(): Promise<void> {
+  // --version / -v: stampa la versione ed esce (prima di tutto).
+  const cliArgs = Bun.argv.slice(2);
+  if (cliArgs.includes("--version") || cliArgs.includes("-v")) {
+    stdout.write(`${CURRENT_VERSION}\n`);
+    return;
+  }
+
   // Titolo + nome-icona della tab del terminale (come Claude Code), solo in TTY
   // (in pipe/non-TTY le sequenze OSC sporcherebbero l'output).
   // OSC 1 = icon/tab name, OSC 2 = window title.

package/src/commands/index.ts

@@ -2,6 +2,7 @@ import type { AgentMode, ThinkingLevel } from "../config.ts";
 import { currentProvider, currentThinking, setThinking, currentModel, setModel } from "../config.ts";
 import { undo, redo } from "../session/snapshot.ts";
 import { loadSkillBody, getCachedRegistry, type SkillInfo } from "../skills.ts";
+import { CURRENT_VERSION } from "../version.ts";
 
 export interface CommandInfo {
   name: string;
@@ -74,6 +75,23 @@ export function isSlashCommand(input: string): boolean {
   return /^\//.test(input);
 }
 
+register("version", "Show the interference version", () => {
+  return `interference v${CURRENT_VERSION}`;
+});
+
+register("update", "Update interference to the latest version", async () => {
+  const proc = Bun.spawn(["npm", "i", "-g", "interference-agent@latest"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const code = await proc.exited;
+  if (code === 0) {
+    return "Updated to the latest version. Restart interference to use it.";
+  }
+  const err = (await new Response(proc.stderr).text()).trim().slice(0, 300);
+  return `Update failed (exit ${code}).${err ? `\n${err}` : ""}\nTry manually: npm i -g interference-agent@latest`;
+});
+
 register("help", "Show available commands", () => {
   const lines = ["Available commands:"];
   for (const cmd of listCommands()) {

package/src/config.ts

@@ -70,6 +70,7 @@ export const PROVIDERS: Record<ProviderId, ProviderDef> = {
     thinkingLevels: ["off", "low", "medium", "high", "max"],
     defaultThinking: "high",
     models: [
+      { id: "claude-sonnet-5", label: "Claude Sonnet 5 (1M ctx)" },
       { id: "claude-opus-4-8", label: "Claude Opus 4.8 (1M ctx)" },
       { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (1M ctx)" },
     ],
@@ -90,14 +91,16 @@ export const PROVIDERS: Record<ProviderId, ProviderDef> = {
   kimi: {
     label: "Moonshot Kimi",
     envKey: "KIMI_API_KEY",
-    defaultModel: "kimi-k2.7",
+    defaultModel: "kimi-k2.7-code",
     kind: "openai-compatible",
     contextLimit: 1_000_000,
     baseURL: "https://api.moonshot.ai/v1",
     thinkingLevels: ["off", "max"],
     defaultThinking: "max",
     models: [
-      { id: "kimi-k2.7", label: "Kimi K2.7 (1M ctx)" },
+      { id: "kimi-k2.7-code", label: "Kimi K2.7 Code (thinking always on)" },
+      { id: "kimi-k2.6", label: "Kimi K2.6 (thinking opzionale)" },
+      { id: "kimi-k2.5", label: "Kimi K2.5" },
     ],
   },
 };
@@ -171,19 +174,13 @@ export interface ReasoningConfig {
   maxOutputTokens?: number;
 }
 
-// Anthropic: livello → budget token del thinking (maxOutputTokens deve superarlo).
-const ANTHROPIC_BUDGET: Record<Exclude<ThinkingLevel, "off">, number> = {
-  low: 8_000,
-  medium: 16_000,
-  high: 32_000,
-  max: 60_000,
-};
-
 /** Traduce il livello di thinking corrente nelle opzioni del provider attivo. */
 export function reasoningConfig(): ReasoningConfig {
   const level = currentThinking();
 
-  switch (config.provider) {
+  // Provider EFFETTIVO: rispetta l'override runtime (`/provider`, `/model`),
+  // non solo `config.provider` (statico da env all'avvio).
+  switch (_providerOverride ?? config.provider) {
     case "deepseek":
       if (level === "off") {
         return { providerOptions: { deepseek: { thinking: { type: "disabled" } } } };
@@ -193,11 +190,18 @@ export function reasoningConfig(): ReasoningConfig {
       };
 
     case "anthropic": {
-      if (level === "off") return {};
-      const budget = ANTHROPIC_BUDGET[level];
+      // Modelli Anthropic moderni (Sonnet 5, Opus 4.8/4.7, Fable 5) NON supportano
+      // `thinking.type: "enabled"` (→ HTTP 400): si usa adaptive thinking + effort.
+      // `off` → solo effort basso (niente adaptive): il modello resta veloce/economico.
+      // (Senza inviare effort, il default lato server è `high` → "off" non spegnerebbe nulla.)
+      if (level === "off") {
+        return { providerOptions: { anthropic: { effort: "low" } } };
+      }
+      // display:"summarized" rende visibile il ragionamento (di default è omesso).
       return {
-        providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: budget } } },
-        maxOutputTokens: budget + 8_000,
+        providerOptions: {
+          anthropic: { thinking: { type: "adaptive", display: "summarized" }, effort: level },
+        },
       };
     }
 
@@ -205,8 +209,15 @@ export function reasoningConfig(): ReasoningConfig {
     case "glm":
       return { extraBody: { thinking: { type: level === "off" ? "disabled" : "enabled" } } };
 
-    case "kimi":
-      if (level === "off") return { extraBody: { thinking: { type: "disabled" } } };
-      return { extraBody: { thinking: { type: "enabled", keep: "all" } } };
+    case "kimi": {
+      // Reasoning Moonshot (campo `reasoning_content`, letto nativamente da @ai-sdk/openai-compatible).
+      // max_tokens ≥ 16000 richiesto: la somma reasoning+content non deve superare max_tokens.
+      // I modelli `*-code` hanno il thinking SEMPRE ON e NON accettano il param `thinking`.
+      const alwaysOn = currentModel().includes("k2.7-code");
+      if (alwaysOn) return { maxOutputTokens: 16_000 };
+      if (level === "off")
+        return { extraBody: { thinking: { type: "disabled" } }, maxOutputTokens: 16_000 };
+      return { extraBody: { thinking: { type: "enabled", keep: "all" } }, maxOutputTokens: 16_000 };
+    }
   }
 }

package/src/cost.ts

@@ -6,6 +6,8 @@ interface Pricing {
 }
 
 const PRICING: Record<string, Pricing> = {
+  // Sonnet 5: standard $3/$15 (intro $2/$10 fino al 2026-08-31).
+  "claude-sonnet-5": { inputPer1M: 3.0, outputPer1M: 15.0 },
   "deepseek-v4-pro": { inputPer1M: 2.0, outputPer1M: 8.0 },
   "deepseek-v4-flash": { inputPer1M: 0.27, outputPer1M: 1.10 },
   "gpt-5.5": { inputPer1M: 5.0, outputPer1M: 30.0 },

package/src/tools/__tests__/mutating.test.ts

@@ -311,7 +311,7 @@ describe("bash tool", () => {
   test("timeout kills process", async () => {
     setRules([{ tool: "bash", decision: "allow" }]);
     const out = await call<string>(bash, { command: "sleep 5", timeout: 500 });
-    expect(out).toContain("exit code");
+    expect(out).toContain("timed out");
   });
 
   test("ask with confirmation", async () => {

package/src/tools/bash.ts

@@ -39,16 +39,35 @@ export const bash = tool({
       cwd: process.cwd(),
       stdout: "pipe",
       stderr: "pipe",
-      timeout: ms,
-      killSignal: "SIGTERM",
     });
 
-    const [stdout, stderr] = await Promise.all([
-      readStream(proc.stdout, OUTPUT_CAP),
-      readStream(proc.stderr, OUTPUT_CAP),
+    // Esecuzione (lettura stream + exit) in gara col timeout. Allo scadere
+    // uccidiamo il processo e ritorniamo SUBITO senza aspettare l'EOF: un figlio
+    // orfano (es. `sleep`) può tenere la pipe aperta dopo la morte della shell e
+    // bloccherebbe la lettura. (L'opzione `timeout` di Bun.spawn non è affidabile
+    // su tutti i runner.)
+    const finished = (async () => {
+      const [stdout, stderr] = await Promise.all([
+        readStream(proc.stdout, OUTPUT_CAP),
+        readStream(proc.stderr, OUTPUT_CAP),
+      ]);
+      const exitCode = await proc.exited;
+      return { stdout, stderr, exitCode };
+    })().catch(() => ({ stdout: "", stderr: "", exitCode: 1 }));
+
+    const result = await Promise.race([
+      finished,
+      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), ms)),
     ]);
 
-    const exitCode = await proc.exited;
+    if (result === "timeout") {
+      try {
+        proc.kill(9);
+      } catch {}
+      return `Command timed out after ${ms}ms and was killed.`;
+    }
+
+    const { stdout, stderr, exitCode } = result;
 
     let output = "";
     if (stdout.length > 0) output += stdout;

package/src/tools/grep.ts

@@ -58,29 +58,35 @@ async function tryRg(
   args.push("--", pattern);
   args.push(cwd);
 
-  const proc = Bun.spawn(["rg", ...args], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const out = await proc.stdout.text();
-  const err = await proc.stderr.text();
-  await proc.exited;
-
-  if (proc.exitCode === 0) {
-    const cwdName = path.relative(process.cwd(), cwd) || ".";
-    return formatMatches(out, pattern, cwdName);
-  }
+  // ripgrep può non essere installato: `Bun.spawn(["rg"])` lancia ENOENT prima
+  // ancora di poter leggere stderr → wrappiamo tutto e torniamo null (→ fallback JS).
+  try {
+    const proc = Bun.spawn(["rg", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const out = await proc.stdout.text();
+    const err = await proc.stderr.text();
+    await proc.exited;
+
+    if (proc.exitCode === 0) {
+      const cwdName = path.relative(process.cwd(), cwd) || ".";
+      return formatMatches(out, pattern, cwdName);
+    }
 
-  if (proc.exitCode === 1) {
-    const cwdName = path.relative(process.cwd(), cwd) || ".";
-    return `No matches for '${pattern}' in ${cwdName}`;
-  }
+    if (proc.exitCode === 1) {
+      const cwdName = path.relative(process.cwd(), cwd) || ".";
+      return `No matches for '${pattern}' in ${cwdName}`;
+    }
 
-  if (err.includes("command not found") || err.includes("No such file")) {
-    return null; // rg not available, fallback to JS
-  }
+    if (err.includes("command not found") || err.includes("No such file")) {
+      return null; // rg non disponibile → fallback JS
+    }
 
-  return `grep error (exit ${proc.exitCode}): ${err || "unknown error"}`;
+    return `grep error (exit ${proc.exitCode}): ${err || "unknown error"}`;
+  } catch {
+    return null; // rg non installato (ENOENT) → fallback JS
+  }
 }
 
 async function jsGrep(
@@ -95,7 +101,7 @@ async function jsGrep(
   try {
     regex = new RegExp(pattern, flags);
   } catch {
-    return `Invalid regex pattern: ${pattern}`;
+    return `grep error: invalid regex pattern '${pattern}'`;
   }
 
   const matches: string[] = [];

package/src/tui/App.tsx

@@ -1,6 +1,6 @@
 import { useState, useRef, useEffect, useCallback } from "react";
 import { Box, Text, Static, useInput, useApp } from "ink";
-import { Spinner } from "@inkjs/ui";
+import { Spinner } from "./Spinner.tsx";
 import TextInput from "ink-text-input";
 import type { ModelMessage } from "ai";
 import { runTurn } from "../agent/loop.ts";
@@ -34,7 +34,10 @@ import { QuestionDialog } from "./QuestionDialog.tsx";
 import { setAnswerHandler, type QuestionSpec, type Answers } from "../tools/question.ts";
 import { ToolStep } from "./ToolStep.tsx";
 import { MarkdownText } from "./MarkdownText.tsx";
-import { USER_BAR, ASSISTANT_BAR } from "./theme.ts";
+import { reasoningSummary } from "./reasoning.ts";
+import { placeholderFor } from "./placeholders.ts";
+import { checkForUpdate, CURRENT_VERSION } from "../version.ts";
+import { USER_BAR, ASSISTANT_BAR, THINKING, THINKING_BODY } from "./theme.ts";
 import { Panel } from "./Panel.tsx";
 
 type HistoryItem = {
@@ -77,6 +80,8 @@ export default function App({ session }: { session: Session }) {
   const [gitBranch, setGitBranch] = useState("");
   const [todos, setTodosState] = useState<Todo[]>(session.todos ?? []);
   const [questions, setQuestions] = useState<QuestionSpec[] | null>(null);
+  const [phIdx, setPhIdx] = useState(0); // indice esempio placeholder (it. 25)
+  const [update, setUpdate] = useState<string | null>(null); // versione più recente (it. 28)
   const { toasts, addToast } = useToast();
   const confirmResolveRef = useRef<((v: boolean) => void) | null>(null);
   const answerResolveRef = useRef<((a: Answers) => void) | null>(null);
@@ -86,6 +91,11 @@ export default function App({ session }: { session: Session }) {
 
   useEffect(() => { sessionRef.current = session; }, [session]);
 
+  // Controllo aggiornamenti (it. 28): non bloccante, throttled, silenzioso offline.
+  useEffect(() => {
+    checkForUpdate().then(setUpdate).catch(() => {});
+  }, []);
+
   // Todos: ripristina dalla sessione e ri-renderizza ad ogni update del tool.
   useEffect(() => {
     setTodos(session.todos ?? []);
@@ -320,6 +330,7 @@ export default function App({ session }: { session: Session }) {
       setReasoning("");
       setToolSteps([]);
       setBusy(false);
+      setPhIdx((i) => i + 1); // ruota l'esempio del placeholder
       aborterRef.current = null;
 
       if (messageQueue.length > 0) {
@@ -537,6 +548,7 @@ ${args ? `Additional context: ${args}` : ""}`;
               provider={currentProvider().label}
               model={currentModel()}
               sessionCount={0}
+              update={update}
             />
           )}
 
@@ -601,7 +613,7 @@ ${args ? `Additional context: ${args}` : ""}`;
                   if (val !== draft) setAcIdx(0);
                   setDraft(val);
                 }}
-                placeholder={busy ? `working… (${messageQueue.length} queued)` : "Type a message (/ for commands)"}
+                placeholder={busy ? `working… (${messageQueue.length} queued)` : placeholderFor(sessionRef.current.meta.mode, phIdx)}
                 onSubmit={onSubmit}
               />
             </Box>
@@ -657,7 +669,9 @@ function RoleBlock({
   );
 }
 
-function ReasoningBlock({ text, live }: { text: string; live?: boolean }) {
+// Fase PENSIERO: header ambra "✻ Thinking/Thought · durata" + corpo attenuato.
+// Distinta dall'esecuzione (icone tool, bianco) e dalla risposta (markdown bianco pieno).
+function ReasoningBlock({ text, live, ms }: { text: string; live?: boolean; ms?: number }) {
   const [elapsed, setElapsed] = useState(0);
 
   useEffect(() => {
@@ -667,25 +681,23 @@ function ReasoningBlock({ text, live }: { text: string; live?: boolean }) {
     return () => clearInterval(timer);
   }, [live]);
 
-  const shown = live
-    ? text.length > 500 ? "…" + text.slice(-500) : text
-    : text.length > 600 ? text.slice(0, 600) + " …" : text;
+  const title = reasoningSummary(text);
+  const titlePart = title ? `: ${title}` : live ? "…" : "";
+  const header = live
+    ? `✻ Thinking${titlePart}${elapsed > 0 ? ` · ${elapsed}s` : ""}`
+    : `✻ Thought${titlePart}${ms ? ` · ${(ms / 1000).toFixed(1)}s` : ""}`;
+
+  // Live: coda in streaming. History: testo dall'inizio, capato.
+  const body = live
+    ? text.length > 400 ? "…" + text.slice(-400) : text
+    : text.length > 700 ? text.slice(0, 700) + " …" : text;
 
   return (
-    <Box
-      flexDirection="column"
-      borderStyle="round"
-      borderColor="gray"
-      borderTop={false}
-      borderRight={false}
-      borderBottom={false}
-      paddingLeft={1}
-      marginBottom={1}
-    >
-      <Text dimColor bold>
-        ┄ thinking{live && elapsed > 0 ? ` ${elapsed}s` : ""}
+    <Box flexDirection="column" paddingLeft={3} marginBottom={1}>
+      <Text color={THINKING} bold>
+        {header}
       </Text>
-      <Text dimColor>{shown}</Text>
+      <Text color={THINKING_BODY}>{body}</Text>
     </Box>
   );
 }
@@ -702,9 +714,7 @@ function MsgBlock({ item }: { item: HistoryItem }) {
   }
   return (
     <Box flexDirection="column">
-      {item.reasoning && (
-        <Text dimColor>┄ thought{item.reasoningMs ? ` · ${secs(item.reasoningMs)}` : ""}</Text>
-      )}
+      {item.reasoning && <ReasoningBlock text={item.reasoning} ms={item.reasoningMs} />}
       <RoleBlock
         color={ASSISTANT_BAR}
         content={item.content}

package/src/tui/ConfirmDialog.tsx

@@ -1,5 +1,6 @@
 import { useState, type FC } from "react";
 import { Box, Text, useInput } from "ink";
+import { BG_ELEMENT } from "./theme.ts";
 
 interface Props {
   tool: string;
@@ -33,11 +34,19 @@ export const ConfirmDialog: FC<Props> = ({ tool, preview, onResolve }) => {
         <Text dimColor>{preview.slice(0, 300)}</Text>
       </Box>
       <Box gap={2}>
-        <Text color={selected === "allow" ? "green" : undefined} bold={selected === "allow"}>
-          {selected === "allow" ? "▸ Allow" : "  Allow"}
+        <Text
+          backgroundColor={selected === "allow" ? BG_ELEMENT : undefined}
+          color={selected === "allow" ? "green" : undefined}
+          bold={selected === "allow"}
+        >
+          {" Allow "}
         </Text>
-        <Text color={selected === "deny" ? "red" : undefined} bold={selected === "deny"}>
-          {selected === "deny" ? "▸ Deny" : "  Deny"}
+        <Text
+          backgroundColor={selected === "deny" ? BG_ELEMENT : undefined}
+          color={selected === "deny" ? "red" : undefined}
+          bold={selected === "deny"}
+        >
+          {" Deny "}
         </Text>
         <Text dimColor>(←→ arrows, Enter, y/n)</Text>
       </Box>