privateer-agent 0.1.0

package/src/components/Root.tsx

@@ -0,0 +1,95 @@
+import React, { useState } from "react";
+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);
+
+  // 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 */
+    }
+    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 */
+    }
+    setConfig(next);
+    setModelSpec(spec);
+    setLoggingIn(false);
+  }
+
+  if (loggingIn) {
+    return <PrivateerLogin onComplete={finishLogin} onCancel={() => 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={() => setOnboarding(true)}
+      onPrivateerLogin={() => setLoggingIn(true)}
+    />
+  );
+}

package/src/components/SessionPicker.tsx

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,121 @@
+import React from "react";
+import { Box, Text } from "ink";
+import { basename } from "node:path";
+import { theme, POSTURE_COLOR } from "./theme.ts";
+import { SHIELD } 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>;
+}
+
+// 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)
+}) {
+  // 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} />
+        <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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,109 @@
+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 ?? "");
+    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

@@ -0,0 +1,203 @@
+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);
+      // ⏺ bullet in its own column so wrapped lines align under the text.
+      return (
+        <Box marginTop={1} flexDirection="column">
+          <Box>
+            <Text color={theme.accent}>{BULLET} </Text>
+            <Box width={bodyWidth}>
+              <Markdown text={body} />
+            </Box>
+          </Box>
+          {recap && (
+            <Box marginTop={1}>
+              <Text color={theme.dim}>{"  "}</Text>
+              <Box width={bodyWidth}>
+                <Text color="white">
+                  {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 (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

@@ -0,0 +1,13 @@
+// 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 DOWN = "↓"; // U+2193 — output tokens streaming down from the model (spinner)