privateer-agent 0.2.1 → 0.3.0

package/src/components/Root.tsx

@@ -1,116 +0,0 @@
-import React, { useState } from "react";
-import { useStdout } from "ink";
-import { App } from "./App.tsx";
-import { Onboarding, type OnboardingResult } from "./Onboarding.tsx";
-import { PrivateerLogin } from "./PrivateerLogin.tsx";
-import { PROVIDER_META } from "../providers/catalog.ts";
-import type { Config, ProviderName } from "../config/schema.ts";
-import { saveGlobalConfig } from "../config/load.ts";
-import { configuredProviders } from "../providers/resolve.ts";
-import type { PrivateerUser } from "../auth/privateer.ts";
-import type { SessionData } from "../memory/store.ts";
-
-// Top-level state machine: shows the onboarding flow (provider selection + key entry)
-// when needed, otherwise the main App. Onboarding can be re-entered from the app via
-// the /login command. Keeping config in state lets newly-saved keys take effect
-// immediately without a restart.
-export function Root({
-  config: initialConfig,
-  modelSpec: initialModel,
-  cwd,
-  resume,
-  startInOnboarding,
-}: {
-  config: Config;
-  modelSpec: string;
-  cwd: string;
-  resume?: SessionData | null;
-  startInOnboarding: boolean;
-}) {
-  const [config, setConfig] = useState<Config>(initialConfig);
-  const [modelSpec, setModelSpec] = useState(initialModel);
-  const [onboarding, setOnboarding] = useState(startInOnboarding);
-  const [loggingIn, setLoggingIn] = useState(false);
-  const { stdout } = useStdout();
-
-  // The App's banner/transcript lives in Ink's <Static> region, which stays in the
-  // terminal scrollback even after the component unmounts. Swapping screens (login,
-  // onboarding) and back therefore stacks a second banner under the stale one. Wipe
-  // screen + scrollback around every top-level swap so each view starts on a clean
-  // page — same trick App uses when the terminal is resized.
-  function swapScreen(update: () => void) {
-    stdout?.write("\x1b[2J\x1b[3J\x1b[H"); // clear screen + scrollback, home cursor
-    update();
-  }
-
-  // Providers that already have credentials — pre-checked when re-running onboarding.
-  const configured = configuredProviders(config)
-    .filter((p) => p.ready)
-    .map((p) => p.name as ProviderName);
-
-  function finish(result: OnboardingResult) {
-    const next: Config = {
-      ...config,
-      defaultModel: result.defaultModel,
-      providers: { ...config.providers, ...result.providers },
-    };
-    try {
-      saveGlobalConfig(next);
-    } catch {
-      /* non-fatal: keys just won't persist to disk this run */
-    }
-    swapScreen(() => {
-      setConfig(next);
-      setModelSpec(result.defaultModel);
-      setOnboarding(false);
-    });
-  }
-
-  // After a successful account login, switch to the Privateer-billed model so the
-  // session immediately uses the account (the provider is now "ready" because
-  // credentials exist on disk). Add a providers.privateer entry so the App's
-  // remount key changes and the new model resolves.
-  function finishLogin(_user: PrivateerUser) {
-    const spec = PROVIDER_META.privateer.defaultModel;
-    const next: Config = {
-      ...config,
-      defaultModel: spec,
-      providers: { ...config.providers, privateer: config.providers.privateer ?? {} },
-    };
-    try {
-      saveGlobalConfig(next);
-    } catch {
-      /* non-fatal: model choice just won't persist this run */
-    }
-    swapScreen(() => {
-      setConfig(next);
-      setModelSpec(spec);
-      setLoggingIn(false);
-    });
-  }
-
-  if (loggingIn) {
-    return (
-      <PrivateerLogin
-        onComplete={finishLogin}
-        onCancel={() => swapScreen(() => setLoggingIn(false))}
-      />
-    );
-  }
-
-  if (onboarding) {
-    return <Onboarding initialSelected={configured} onComplete={finish} />;
-  }
-
-  return (
-    <App
-      key={modelSpec + Object.keys(config.providers).join(",")}
-      model={modelSpec}
-      config={config}
-      cwd={cwd}
-      resume={resume}
-      onLogin={() => swapScreen(() => setOnboarding(true))}
-      onPrivateerLogin={() => swapScreen(() => setLoggingIn(true))}
-    />
-  );
-}

package/src/components/SessionPicker.tsx

@@ -1,64 +0,0 @@
-import React, { useState } from "react";
-import { Box, Text, useInput } from "ink";
-import { theme } from "./theme.ts";
-import { POINTER } from "./figures.ts";
-import type { SessionMeta } from "../memory/store.ts";
-
-function ago(iso: string): string {
-  const s = Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 1000));
-  if (s < 60) return `${s}s ago`;
-  if (s < 3600) return `${Math.round(s / 60)}m ago`;
-  if (s < 86400) return `${Math.round(s / 3600)}h ago`;
-  return `${Math.round(s / 86400)}d ago`;
-}
-
-// Lists past sessions (newest first). Move with ↑/↓ (or j/k); Enter resumes the
-// selected session, Esc cancels.
-export function SessionPicker({
-  sessions,
-  onResume,
-  onCancel,
-}: {
-  sessions: SessionMeta[];
-  onResume: (id: string) => void;
-  onCancel: () => void;
-}) {
-  const [sel, setSel] = useState(0);
-
-  useInput((input, key) => {
-    if (key.escape) return void onCancel();
-    if (sessions.length === 0) return;
-    if (key.upArrow || input === "k") return void setSel((s) => (s - 1 + sessions.length) % sessions.length);
-    if (key.downArrow || input === "j") return void setSel((s) => (s + 1) % sessions.length);
-    if (key.return) return void onResume(sessions[Math.min(sel, sessions.length - 1)].id);
-  });
-
-  if (sessions.length === 0) {
-    return (
-      <Box flexDirection="column" borderStyle="round" borderColor={theme.accent} paddingX={1}>
-        <Text color={theme.dim}>No saved sessions yet for this project. Esc to close.</Text>
-      </Box>
-    );
-  }
-
-  return (
-    <Box flexDirection="column" borderStyle="round" borderColor={theme.accent} paddingX={1}>
-      <Text color={theme.accent}>Resume a session</Text>
-      {sessions.map((s, i) => {
-        const active = i === Math.min(sel, sessions.length - 1);
-        return (
-          <Box key={s.id} gap={1}>
-            <Text color={active ? theme.accent : theme.dim}>{active ? POINTER : " "}</Text>
-            <Text color={active ? theme.accent : undefined}>{s.preview}</Text>
-            <Text color={theme.dim}>
-              ({ago(s.updatedAt)}, {s.messageCount} msg{s.messageCount === 1 ? "" : "s"})
-            </Text>
-          </Box>
-        );
-      })}
-      <Text color={theme.dim}>
-        <Text color={theme.accent}>↑↓</Text> move · <Text color={theme.accent}>enter</Text> resume · esc cancel
-      </Text>
-    </Box>
-  );
-}

package/src/components/StatusBar.tsx

@@ -1,131 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import { basename } from "node:path";
-import { theme, POSTURE_COLOR } from "./theme.ts";
-import { SHIELD, DOT } from "./figures.ts";
-import { useTerminalWidth } from "./useTerminalWidth.ts";
-import { type UsageTotals } from "../engine/events.ts";
-import type { ZdrState } from "./useZdrShield.ts";
-import type { TeeState } from "./useTeeShield.ts";
-
-// OpenRouter ZDR shield: a colored "⛉ ZDR" segment summarizing the selected model's
-// zero-data-retention posture. Dim "⛉ ZDR?" while loading or when the posture is
-// unknown (no key / fetch error); nothing at all for non-OpenRouter models.
-function ZdrBadge({ zdr }: { zdr?: ZdrState }) {
-  if (!zdr || zdr.kind === "hidden") return null;
-  if (zdr.kind === "ready") {
-    return <Text color={POSTURE_COLOR[zdr.posture]}>{`${SHIELD} ZDR · `}</Text>;
-  }
-  return <Text color={theme.dim}>{`${SHIELD} ZDR? · `}</Text>;
-}
-
-// NEAR AI TEE shield: a colored "⛉ TEE" segment summarizing whether the selected
-// model's confidential-inference enclave attested successfully. Dim "⛉ TEE?" while
-// loading or when unknown (no key / fetch error); nothing for non-NEAR models.
-function TeeBadge({ tee }: { tee?: TeeState }) {
-  if (!tee || tee.kind === "hidden") return null;
-  if (tee.kind === "ready") {
-    return <Text color={POSTURE_COLOR[tee.posture]}>{`${SHIELD} TEE · `}</Text>;
-  }
-  return <Text color={theme.dim}>{`${SHIELD} TEE? · `}</Text>;
-}
-
-// Remote-access badge: a green "● remote" segment shown while /remote-access is on,
-// signalling the Privateer app can drive this terminal (send prompts / approve its
-// tool calls). Nothing at all when remote access is off.
-function RemoteBadge({ remote }: { remote?: boolean }) {
-  if (!remote) return null;
-  return <Text color={theme.success}>{`${DOT} remote · `}</Text>;
-}
-
-// Compact token count: 100, 1k, 1m, 1b — one decimal place above 1k, trimmed of
-// trailing ".0", so 1500 → "1.5k" and 2000 → "2k".
-export function formatTokens(n: number): string {
-  const units: [number, string][] = [
-    [1e9, "b"],
-    [1e6, "m"],
-    [1e3, "k"],
-  ];
-  for (const [size, suffix] of units) {
-    if (n >= size) return `${(n / size).toFixed(1).replace(/\.0$/, "")}${suffix}`;
-  }
-  return `${n}`;
-}
-
-// Human-readable elapsed time from milliseconds: 8200 → "8s", 83000 → "1m 23s",
-// 3723000 → "1h 2m". Drops zero-valued leading units so short turns stay terse.
-export function formatDuration(ms: number): string {
-  const total = Math.max(0, Math.round(ms / 1000));
-  const h = Math.floor(total / 3600);
-  const m = Math.floor((total % 3600) / 60);
-  const s = total % 60;
-  if (h > 0) return `${h}h ${m}m`;
-  if (m > 0) return `${m}m ${s}s`;
-  return `${s}s`;
-}
-
-// The footer line rendered directly under the prompt box. The headline is a
-// Claude-Code-style context-window gauge ("how full is the window right now"),
-// not the cumulative billed total — a one-word message barely moves it. The gauge
-// sits in a leading bracket so it survives right-edge truncation; model · cwd
-// follow and clip first. Cost accounting (cache hits, last-turn / session totals)
-// is intentionally not here — it lives in `/context`. The active permission mode
-// is shown separately by <ModeHint>.
-//
-// Both sides truncate (never wrap) and the row is bounded a few columns short of
-// the terminal so it always stays a single physical line — see useTerminalWidth.
-
-// "84k/120k · 70%" when a budget is set, else a bare "84k ctx".
-function formatContext(ctx?: { used: number; budget: number }): string {
-  if (!ctx) return "";
-  if (ctx.budget > 0) {
-    const pct = Math.round((ctx.used / ctx.budget) * 100);
-    return `${formatTokens(ctx.used)}/${formatTokens(ctx.budget)} · ${pct}%`;
-  }
-  return `${formatTokens(ctx.used)} ctx`;
-}
-
-export function StatusBar(props: {
-  modelSpec: string;
-  cwd: string;
-  usage: UsageTotals;
-  context?: { used: number; budget: number };
-  lastTurn?: UsageTotals;
-  custom?: string; // settings-driven status line; overrides the default when set
-  zdr?: ZdrState; // OpenRouter ZDR posture for the selected model (default line only)
-  tee?: TeeState; // NEAR AI TEE attestation posture for the selected model (default line only)
-  remote?: boolean; // /remote-access is on — the app can drive this terminal (default line only)
-}) {
-  // Stay clear of the right edge (parent paddingX={1} plus a 2-col safety gap) so
-  // the line never reaches the final column and the terminal never reflows it.
-  const width = Math.max(20, useTerminalWidth() - 4);
-  if (props.custom) {
-    return (
-      <Box marginTop={1} width={width}>
-        <Text color={theme.dim} wrap="truncate-end">
-          {props.custom}
-        </Text>
-      </Box>
-    );
-  }
-  // The bar carries only the context-window gauge ("how full is the window right
-  // now") plus model · cwd. The cumulative cost accounting — cache hits, last-turn
-  // and session billed totals — lives in `/context`, so the always-on line stays
-  // quiet and the live output count belongs to the spinner. See effectiveTokens.
-  const diag = formatContext(props.context);
-  return (
-    <Box marginTop={1} width={width}>
-      <Text wrap="truncate-end">
-        <ZdrBadge zdr={props.zdr} />
-        <TeeBadge tee={props.tee} />
-        <RemoteBadge remote={props.remote} />
-        <Text color={theme.accent}>⚓ privateer</Text>
-        {diag ? <Text color={theme.dim}>{` [${diag}]`}</Text> : null}
-        <Text color={theme.dim}> (shift+tab to cycle)</Text>
-        <Text color={theme.dim}>
-          {` · ${props.modelSpec} · ${basename(props.cwd) || props.cwd}`}
-        </Text>
-      </Text>
-    </Box>
-  );
-}

package/src/components/TodoPanel.tsx

@@ -1,36 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import type { TodoItem } from "../tools/todoStore.ts";
-import { theme } from "./theme.ts";
-
-const MARK: Record<TodoItem["status"], string> = {
-  completed: "✔",
-  in_progress: "▸",
-  pending: "○",
-};
-
-// The live task panel, rendered above the status bar: completed items
-// dimmed/struck, the in-progress item highlighted. Hidden when there are no todos.
-export function TodoPanel({ todos }: { todos: TodoItem[] }) {
-  if (todos.length === 0) return null;
-  const done = todos.filter((t) => t.status === "completed").length;
-
-  return (
-    <Box flexDirection="column" marginTop={1} borderStyle="round" borderColor={theme.dim} paddingX={1}>
-      <Text dimColor>
-        Tasks {done}/{todos.length}
-      </Text>
-      {todos.map((t, i) => {
-        const label = t.status === "in_progress" ? t.activeForm ?? t.content : t.content;
-        const color =
-          t.status === "in_progress" ? theme.accent : t.status === "completed" ? theme.success : undefined;
-        return (
-          <Text key={i} color={color} dimColor={t.status === "pending"}>
-            {MARK[t.status]}{" "}
-            <Text strikethrough={t.status === "completed"}>{label}</Text>
-          </Text>
-        );
-      })}
-    </Box>
-  );
-}

package/src/components/ToolCallView.tsx

@@ -1,113 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import Spinner from "ink-spinner";
-import type { ToolEntry } from "./types.ts";
-import { theme, toolDisplayName } from "./theme.ts";
-import { BULLET, TREE } from "./figures.ts";
-
-// A one-line summary of a tool's input, picking the most relevant field per tool.
-function summarizeInput(name: string, input: unknown): string {
-  const o = (input ?? {}) as Record<string, unknown>;
-  switch (name) {
-    case "read":
-    case "write":
-    case "edit":
-      return String(o.path ?? "");
-    case "bash":
-      return String(o.command ?? "");
-    case "glob":
-      return String(o.pattern ?? "");
-    case "grep":
-      return String(o.pattern ?? "") + (o.glob ? ` (${o.glob})` : "");
-    case "task":
-      return String(o.description ?? o.subagent_type ?? "");
-    case "ask_user":
-      return String(o.question ?? "");
-    case "worktree":
-      return String(o.action ?? "") + (o.name ? ` ${o.name}` : "");
-    default:
-      try {
-        return JSON.stringify(o);
-      } catch {
-        return "";
-      }
-  }
-}
-
-// Show the first few lines of tool output so the transcript stays compact.
-function previewOutput(text: string, maxLines = 6): { lines: string[]; more: number } {
-  const all = text.replace(/\n+$/, "").split("\n");
-  return { lines: all.slice(0, maxLines), more: Math.max(0, all.length - maxLines) };
-}
-
-// Red/green line diff rendered from an edit tool's input (no engine data needed).
-function EditDiff({ input }: { input: unknown }) {
-  const o = (input ?? {}) as Record<string, unknown>;
-  const removed = String(o.old_string ?? "").split("\n");
-  const added = String(o.new_string ?? "").split("\n");
-  return (
-    <Box flexDirection="column" marginLeft={2}>
-      <Text color={theme.dim}>{TREE} </Text>
-      {removed.map((l, i) => (
-        <Text key={`r${i}`} color={theme.diffRemoved}>
-          {"  - "}
-          {l}
-        </Text>
-      ))}
-      {added.map((l, i) => (
-        <Text key={`a${i}`} color={theme.diffAdded}>
-          {"  + "}
-          {l}
-        </Text>
-      ))}
-    </Box>
-  );
-}
-
-export function ToolCallView({ entry, verbose }: { entry: ToolEntry; verbose?: boolean }) {
-  const summary = summarizeInput(entry.name, entry.input);
-  const body = entry.status === "error" ? entry.error ?? "" : entry.output ?? "";
-  const { lines, more } = previewOutput(body, verbose ? Number.MAX_SAFE_INTEGER : 6);
-  const isEditDiff = entry.name === "edit" && entry.status !== "error";
-
-  return (
-    <Box flexDirection="column" marginTop={1}>
-      <Box gap={1}>
-        {entry.status === "running" ? (
-          <Text color={theme.accent}>
-            <Spinner type="dots" />
-          </Text>
-        ) : (
-          <Text color={entry.status === "error" ? theme.error : theme.accent}>{BULLET}</Text>
-        )}
-        <Text>
-          <Text bold color={theme.accent}>
-            {toolDisplayName(entry.name)}
-          </Text>
-          <Text color={theme.dim}>({summary})</Text>
-        </Text>
-      </Box>
-
-      {entry.status !== "running" &&
-        (isEditDiff ? (
-          <EditDiff input={entry.input} />
-        ) : (
-          body.trim() !== "" && (
-            <Box flexDirection="column" marginLeft={2}>
-              {lines.map((l, i) => (
-                <Text
-                  key={i}
-                  color={entry.status === "error" ? theme.error : theme.dim}
-                  dimColor={entry.status !== "error"}
-                >
-                  {i === 0 ? `${TREE}  ` : "   "}
-                  {l}
-                </Text>
-              ))}
-              {more > 0 && <Text color={theme.dim}>{"   "}… (+{more} more lines)</Text>}
-            </Box>
-          )
-        ))}
-    </Box>
-  );
-}

package/src/components/Transcript.tsx

@@ -1,210 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import type { Entry, Row, ToolEntry } from "./types.ts";
-import { ToolCallView } from "./ToolCallView.tsx";
-import { AgentGroupView } from "./AgentGroupView.tsx";
-import { theme } from "./theme.ts";
-import { Markdown } from "./Markdown.tsx";
-import { BULLET, WELCOME } from "./figures.ts";
-import { useTerminalWidth } from "./useTerminalWidth.ts";
-
-// Width of the marker gutter ("⏺ ", "✻ ", or two-space indent) that sits left of a
-// wrapped body. Subtracting it from the terminal width gives the body a *definite*
-// column count, which is what keeps wrapping on word boundaries: a flex body with no
-// fixed width lets Yoga measure the text's intrinsic size and then shrink the box
-// below a word's length, at which point Ink falls back to breaking mid-word.
-const GUTTER = 2;
-
-// Visual height of `text` once wrapped to `cols` columns — `\n`-lines plus the
-// extra rows each long line wraps onto.
-export function visualRows(text: string, cols: number): number {
-  let rows = 0;
-  for (const ln of text.split("\n")) rows += Math.max(1, Math.ceil(ln.length / Math.max(1, cols)));
-  return rows;
-}
-
-// Trim a still-streaming block to roughly its last `maxRows` wrapped rows so the live
-// region stays within the terminal. The hidden prefix isn't lost: the full text is
-// what gets committed to <Static> when the turn ends, so it lands intact in
-// scrollback. Returns the text unchanged when it already fits.
-export function clampStreamingText(text: string, maxRows: number, cols: number): string {
-  const lines = text.split("\n");
-  const width = Math.max(1, cols);
-  let rows = 0;
-  let i = lines.length;
-  while (i > 0) {
-    const r = Math.max(1, Math.ceil(lines[i - 1].length / width));
-    if (rows + r > maxRows - 1) break; // reserve one row for the "…hidden" marker
-    rows += r;
-    i--;
-  }
-  if (i === 0) return text;
-  return `⋮ ${i} earlier line${i === 1 ? "" : "s"} hidden — shown in full when complete\n${lines.slice(i).join("\n")}`;
-}
-
-// Collapse runs of two-or-more consecutive `task` tool entries (sub-agents the model
-// fanned out in one turn) into a single grouped row, leaving everything else as-is. A
-// lone task stays a normal tool call. Grouping is purely a render concern, so it runs
-// over the entry list at paint time rather than mutating the transcript.
-export function groupRows(entries: Entry[]): Row[] {
-  const rows: Row[] = [];
-  let run: ToolEntry[] = [];
-  const flush = () => {
-    if (run.length >= 2) rows.push({ kind: "agent-group", agents: run });
-    else rows.push(...run);
-    run = [];
-  };
-  for (const e of entries) {
-    if (e.kind === "tool" && e.name === "task") run.push(e);
-    else {
-      flush();
-      rows.push(e);
-    }
-  }
-  flush();
-  return rows;
-}
-
-// Pull a trailing `recap: …` line off an assistant message so it can be styled
-// separately. Only the last line is considered, and only if it starts with the
-// marker; otherwise the whole text is the body and there's no recap.
-function splitRecap(text: string): { body: string; recap?: string } {
-  const trimmed = text.replace(/\s+$/, "");
-  const nl = trimmed.lastIndexOf("\n");
-  const lastLine = trimmed.slice(nl + 1);
-  if (/^recap:\s*/i.test(lastLine)) {
-    return { body: trimmed.slice(0, nl < 0 ? 0 : nl).replace(/\s+$/, ""), recap: lastLine };
-  }
-  return { body: text };
-}
-
-export function EntryView({
-  entry,
-  verbose,
-  collapsed,
-}: {
-  entry: Entry;
-  verbose?: boolean;
-  collapsed?: boolean;
-}) {
-  const cols = useTerminalWidth();
-  // Definite body width so wrapped text breaks on word boundaries (see GUTTER).
-  const bodyWidth = Math.max(20, cols - GUTTER);
-  switch (entry.kind) {
-    case "user":
-      return (
-        <Box marginTop={1}>
-          <Text color={theme.dim}>{"> "}</Text>
-          <Text color={theme.dim}>{entry.text}</Text>
-        </Box>
-      );
-    case "assistant": {
-      // Split off a trailing `recap:` line so it can render dimmed below the
-      // response body. The model is asked to end each turn with one such line.
-      const { body, recap } = splitRecap(entry.text);
-      const hasBody = body.trim().length > 0;
-      // Nothing to paint: a whitespace-only entry (possible in transcripts
-      // persisted before the turn loop filtered them) would render a bare ⏺.
-      if (!hasBody && !recap) return null;
-      // ⏺ bullet in its own column so wrapped lines align under the text.
-      return (
-        <Box marginTop={1} flexDirection="column">
-          {hasBody && (
-            <Box>
-              <Text color={theme.accent}>{BULLET} </Text>
-              <Box width={bodyWidth}>
-                <Markdown text={body} />
-              </Box>
-            </Box>
-          )}
-          {recap && (
-            <Box marginTop={hasBody ? 1 : 0}>
-              <Text color={theme.dim}>{"  "}</Text>
-              <Box width={bodyWidth}>
-                <Text color={theme.dim} dimColor italic>
-                  {recap}
-                </Text>
-              </Box>
-            </Box>
-          )}
-        </Box>
-      );
-    }
-    case "thinking": {
-      // The model's reasoning, rendered dimmed under a thinking mark. When
-      // collapsed (Ctrl+O), show just a one-line summary instead of the full text.
-      if (entry.text.trim() === "") return null;
-      if (collapsed) {
-        const lineCount = entry.text.trim() === "" ? 0 : entry.text.trim().split("\n").length;
-        return (
-          <Box marginTop={1}>
-            <Text color={theme.dim} dimColor>
-              {WELCOME} Thinking{lineCount ? ` (${lineCount} lines)` : ""} — Ctrl+O to expand
-            </Text>
-          </Box>
-        );
-      }
-      return (
-        <Box marginTop={1}>
-          <Text color={theme.dim}>{WELCOME} </Text>
-          <Box width={bodyWidth}>
-            <Text color={theme.dim} dimColor>
-              {entry.text}
-            </Text>
-          </Box>
-        </Box>
-      );
-    }
-    case "tool":
-      return <ToolCallView entry={entry} verbose={verbose} />;
-    case "notice":
-      return (
-        <Box marginTop={1} flexDirection="column">
-          {entry.text.split("\n").map((l, i) => (
-            <Text
-              key={i}
-              color={entry.tone === "error" ? theme.error : theme.dim}
-              dimColor={entry.tone !== "error"}
-            >
-              {l}
-            </Text>
-          ))}
-          {entry.hint &&
-            entry.hint.split("\n").map((l, i) => (
-              <Text key={`hint-${i}`} color={theme.dim} dimColor>
-                {l}
-              </Text>
-            ))}
-        </Box>
-      );
-  }
-}
-
-// Render one grouped row: a fanned-out agent block, or any other single entry.
-export function RowView({
-  row,
-  verbose,
-  collapsed,
-}: {
-  row: Row;
-  verbose?: boolean;
-  collapsed?: boolean;
-}) {
-  return row.kind === "agent-group" ? (
-    <AgentGroupView agents={row.agents} collapsed={collapsed} />
-  ) : (
-    <EntryView entry={row} verbose={verbose} collapsed={collapsed} />
-  );
-}
-
-// Render a list of finalized entries (used inside Ink's <Static> for the committed
-// transcript) — kept as a plain map so the same RowView powers live rendering too.
-export function Transcript({ entries }: { entries: Entry[] }) {
-  return (
-    <Box flexDirection="column">
-      {groupRows(entries).map((row, i) => (
-        <RowView key={i} row={row} />
-      ))}
-    </Box>
-  );
-}

package/src/components/figures.ts

@@ -1,14 +0,0 @@
-// Unicode figures used as markers and status glyphs across the TUI.
-export const BULLET = "⏺"; // U+23FA — prefixes assistant messages and tool calls
-export const TREE = "⎿"; // U+23BF — connects a tool's result under its call
-export const BRANCH = "├"; // tee — a non-final child in the grouped agents tree
-export const CORNER = "└"; // elbow — the final child in a tree
-export const VLINE = "│"; // vertical — continues the trunk past a non-final child
-export const WELCOME = "✻"; // U+273B — teardrop-asterisk welcome mark
-export const EFFORT = { low: "○", medium: "◐", high: "●", max: "◉" } as const;
-export const POINTER = "❯"; // selection pointer in menus and the prompt caret
-export const FAST_FORWARD = "⏵⏵"; // marks an "on" permission mode below the prompt
-export const PAUSE = "⏸"; // marks plan mode (paused execution) below the prompt
-export const SHIELD = "⛉"; // U+26C9 — OpenRouter ZDR posture marker in the status bar
-export const DOT = "●"; // U+25CF — "live" marker; the remote-access badge in the status bar
-export const DOWN = "↓"; // U+2193 — output tokens streaming down from the model (spinner)