@taicho-ai/cli 0.1.0

package/src/ui/slash.ts

@@ -0,0 +1,270 @@
+/** Pure REPL slash-command dispatch. Returns lines to print; no I/O of its own (store fns injected). */
+import type { RegistryRow } from "@taicho-ai/framework/store/roster";
+import type { RunTrace } from "@taicho-ai/contracts/trace";
+import type { PolicyNote } from "@taicho-ai/contracts/policy";
+import { McpServerConfig } from "@taicho-ai/framework/store/config";
+import type { McpServerStatus } from "@taicho-ai/framework/core/mcp/manager";
+import { rollupCosts, formatCostRollup } from "@taicho-ai/framework/core/costs";
+import { DEFAULT_TEAM_ID } from "@taicho-ai/contracts/team";
+
+export type Line = { kind: "user" | "agent" | "system"; from?: string; text: string; rendered?: boolean };
+
+export interface SlashCommand { name: string; summary: string; usage?: string; requiresArg?: boolean; }
+
+/** Single source of truth for slash commands — drives both /help and the live suggester. */
+export const COMMANDS: SlashCommand[] = [
+  { name: "help", summary: "list commands" },
+  { name: "agents", summary: "list the squad", usage: "[reindex]" },
+  { name: "teams", summary: "list teams, their leads, and their members" },
+  { name: "workflows", summary: "browse team workflows and their run state" },
+  { name: "costs", summary: "cross-session spend rollup (agent / day / model)", usage: "[agent]" },
+  { name: "tasks", summary: "list / cancel background tasks", usage: "[cancel <id>]" },
+  { name: "schedules", summary: "scheduled/triggered runs (cron / interval / watch)", usage: "list | add <goal> --every … | remove <id> | run <id>" },
+  { name: "view", summary: "switch the live view (persists)", usage: "bar|panes|both" },
+  { name: "plan", summary: "show/hide the pinned plan panel (persists)", usage: "[on|off]" },
+  { name: "teach", summary: "teach an agent a standing instruction", usage: "<agent> <correction>", requiresArg: true },
+  { name: "policies", summary: "list an agent's coaching notes; approve a proposed one", usage: "<agent> | approve <pol_id>", requiresArg: true },
+  { name: "forget", summary: "remove a coaching note", usage: "<agent> <pol_id>", requiresArg: true },
+  { name: "mcp", summary: "manage MCP servers", usage: "[list|add|remove|login] …" },
+  { name: "kb", summary: "manage the knowledgebase", usage: "sync | list [filter] | forget <filter> | reindex" },
+  { name: "skills", summary: "manage agent skills", usage: "list | show <id|name> | remove <id> | reindex" },
+  { name: "artifacts", summary: "browse the squad's artifacts — runs also end here", usage: "" },
+  { name: "clear", summary: "clear the conversation — wipe the screen and forget history" },
+  { name: "status", summary: "show the auth source" },
+  { name: "login", summary: "sign in with a ChatGPT subscription", usage: "openai" },
+  { name: "logout", summary: "sign out", usage: "openai" },
+];
+
+/** Wrap an index by delta within [0, len); returns 0 for an empty list. */
+export function cycleIndex(current: number, len: number, delta: number): number {
+  if (len <= 0) return 0;
+  return (((current + delta) % len) + len) % len;
+}
+
+/** Commands matching what the captain is typing, while still on the command NAME (before a space). */
+export function suggestCommands(buffer: string): SlashCommand[] {
+  if (!buffer.startsWith("/")) return [];
+  const rest = buffer.slice(1);
+  if (rest.includes(" ")) return [];
+  return COMMANDS.filter((c) => c.name.startsWith(rest.toLowerCase()));
+}
+
+export interface SlashDeps {
+  roster: RegistryRow[];
+  /** Plan 19: the squad's teams, captain-owned files. Empty on a squad that has never made one. */
+  teams: { id: string; charter: string; lead?: string }[];
+  listTraces: (agentId?: string) => RunTrace[]; // still the source /costs rolls up
+  listPolicies: (agentId: string) => PolicyNote[];
+  deletePolicy: (agentId: string, polId: string) => boolean;
+  /** Approve a `proposed` note by id (search is caller-scoped across agents). Null ⇒ no such note. */
+  approvePolicy: (polId: string) => PolicyNote | null;
+}
+
+const sys = (text: string): Line => ({ kind: "system", text });
+
+export function runSlash(cmd: string, arg: string, deps: SlashDeps): Line[] {
+  if (cmd === "help")
+    return [
+      sys("commands (type / to see these; Tab completes):"),
+      ...COMMANDS.map((c) => sys(`  /${c.name}${c.usage ? " " + c.usage : ""} — ${c.summary}`)),
+      sys("  @<agent> <task> — address an agent · ESC to quit"),
+    ];
+  if (cmd === "agents")
+    return deps.roster.map((r) => {
+      // Show only EXPLICIT teams — every agent is on `default`, so printing it on each line is noise.
+      // (The Org browser shows default; this flat list stays terse.)
+      const teams = (r.teams ?? []).filter((t) => t !== DEFAULT_TEAM_ID);
+      return sys(`  ${r.is_root ? "*" : "-"} ${r.id}: ${r.role}${teams.length ? ` (${teams.join(" · ")})` : ""}`);
+    });
+  if (cmd === "teams") {
+    if (!deps.teams.length)
+      return [sys("  (no teams) — a team is a captain-owned file at teams/<id>/team.md")];
+    const out: Line[] = [];
+    for (const t of deps.teams) {
+      const members = deps.roster.filter((r) => r.teams?.includes(t.id));
+      const how = t.lead ? `lead: ${t.lead}` : "routed by capability";
+      out.push(sys(`  ${t.id}: ${t.charter}`));
+      out.push(sys(`    ${how} · ${members.length} agent${members.length === 1 ? "" : "s"}`));
+      for (const m of members) out.push(sys(`      ${m.id === t.lead ? "*" : "-"} ${m.id}: ${m.role}`));
+    }
+    return out;
+  }
+  if (cmd === "costs") {
+    // Cross-session spend rollup from the per-run RunTrace records. Honest about subscription
+    // (costUsd:null) runs — reports their tokens, never a fabricated $0. Optional [agent] scopes it.
+    return formatCostRollup(rollupCosts(deps.listTraces(arg || undefined))).map(sys);
+  }
+  if (cmd === "policies") {
+    const parts = arg.split(/\s+/).filter(Boolean);
+    // `/policies approve <pol_id>` — the captain gate that flips a `proposed` note (e.g. a repeated-
+    // failure coaching proposal) to `approved`, the only status run.ts applies. Id-only: the ⚑ proposal
+    // message hands the captain the id, and approvePolicy locates its owning agent.
+    if (parts[0] === "approve") {
+      const polId = parts[1];
+      if (!polId) return [sys("  usage: /policies approve <pol_id>")];
+      const note = deps.approvePolicy(polId);
+      if (!note) return [sys(`  no proposed policy "${polId}" — check the id (⚑ message or /policies <agent>)`)];
+      return [sys(`  ✓ approved ${note.id} for ${note.agent} — WHEN ${note.when}: ${note.do}`)];
+    }
+    const agentId = parts[0];
+    if (!agentId) return [sys("  usage: /policies <agent>  ·  /policies approve <pol_id>")];
+    const notes = deps.listPolicies(agentId);
+    if (!notes.length) return [sys("  (no policies)")];
+    return notes.map((n) => sys(`  [${n.id}] (${n.status}) WHEN ${n.when}: ${n.do}`));
+  }
+  if (cmd === "forget") {
+    const [agentId, polId] = arg.split(/\s+/);
+    if (!agentId || !polId) return [sys("  usage: /forget <agentId> <pol_id>")];
+    return [sys(deps.deletePolicy(agentId, polId) ? `  forgot ${polId}` : `  no such policy: ${polId}`)];
+  }
+  return [sys(`  unknown command: /${cmd}`)];
+}
+
+// ---- /mcp parsing & formatting (pure; the async handler lives in App.tsx) -------------------------
+
+export type McpCommand =
+  | { kind: "list" }
+  | { kind: "add"; name: string; spec: McpServerConfig }
+  | { kind: "remove"; name: string }
+  | { kind: "login"; name: string }
+  | { kind: "reconnect"; name: string }
+  | { kind: "error"; message: string };
+
+/** Split on whitespace but keep "double quoted" runs together (so --header "K: V" survives, and a
+ *  cron expr `--cron "0 9 * * *"` stays one token). Shared by /mcp and /schedules parsing. */
+export function tokenize(s: string): string[] {
+  const out: string[] = [];
+  let cur = "", q = false, has = false;
+  for (const c of s) {
+    if (c === '"') { q = !q; has = true; continue; }
+    if (!q && /\s/.test(c)) { if (has) { out.push(cur); cur = ""; has = false; } continue; }
+    cur += c; has = true;
+  }
+  if (has) out.push(cur);
+  return out;
+}
+
+/** Parse the argument string of `/mcp …` into a command. Supports:
+ *   (bare) | list
+ *   add <name> <command> [args…] [--env K=V …]            (stdio)
+ *   add <name> <https://url> [--oauth] [--header "K: V" …] (http)
+ *   remove|login|reconnect <name>                                                     */
+const NAME_RE = /^[a-z0-9][a-z0-9_-]*$/i; // no `/` (it delimits server/tool refs), no spaces
+
+export function parseMcpCommand(arg: string): McpCommand {
+  const tokens = tokenize(arg.trim());
+  const sub = (tokens[0] ?? "list").toLowerCase();
+  if (sub === "list" || sub === "ls") return { kind: "list" };
+
+  if (sub === "remove" || sub === "rm" || sub === "login" || sub === "reconnect") {
+    const name = tokens[1];
+    if (!name) return { kind: "error", message: `usage: /mcp ${sub} <name>` };
+    if (!NAME_RE.test(name)) return { kind: "error", message: `invalid server name "${name}" (use letters, digits, _ or -)` };
+    const kind = sub === "rm" ? "remove" : (sub as "remove" | "login" | "reconnect");
+    return { kind, name };
+  }
+
+  if (sub === "add") {
+    const name = tokens[1];
+    if (!name) return { kind: "error", message: "usage: /mcp add <name> <command…|https://url> [flags]" };
+    if (!NAME_RE.test(name)) return { kind: "error", message: `invalid server name "${name}" (use letters, digits, _ or -)` };
+    const rest = tokens.slice(2);
+    const positionals: string[] = [];
+    const headers: Record<string, string> = {};
+    const env: Record<string, string> = {};
+    let oauth = false;
+    for (let i = 0; i < rest.length; i++) {
+      const t = rest[i];
+      if (t === "--oauth") oauth = true;
+      else if (t === "--header") { const kv = rest[++i] ?? ""; const j = kv.indexOf(":"); if (j > 0) headers[kv.slice(0, j).trim()] = kv.slice(j + 1).trim(); }
+      else if (t === "--env") { const kv = rest[++i] ?? ""; const j = kv.indexOf("="); if (j > 0) env[kv.slice(0, j)] = kv.slice(j + 1); }
+      else positionals.push(t);
+    }
+    if (!positionals.length) return { kind: "error", message: "usage: /mcp add <name> <command…|https://url> [flags]" };
+    const head = positionals[0];
+    const isHttp = /^https?:\/\//.test(head);
+    if (isHttp && Object.keys(env).length) return { kind: "error", message: "--env applies to stdio servers, not an http url" };
+    if (!isHttp && (Object.keys(headers).length || oauth)) return { kind: "error", message: "--header/--oauth apply to http servers, not a stdio command" };
+    const raw: unknown = isHttp
+      ? { url: head, ...(Object.keys(headers).length ? { headers } : {}), ...(oauth ? { auth: "oauth" } : {}) }
+      : { command: head, ...(positionals.length > 1 ? { args: positionals.slice(1) } : {}), ...(Object.keys(env).length ? { env } : {}) };
+    const parsed = McpServerConfig.safeParse(raw);
+    if (!parsed.success) return { kind: "error", message: `invalid server spec: ${parsed.error.issues[0]?.message ?? "bad input"}` };
+    return { kind: "add", name, spec: parsed.data };
+  }
+
+  return { kind: "error", message: `unknown /mcp subcommand "${sub}" (try list, add, remove, login, reconnect)` };
+}
+
+const statusIcon = (s: McpServerStatus["status"]): string => (s === "connected" ? "●" : s === "needs-auth" ? "◌" : "✗");
+
+export function formatMcpStatus(servers: McpServerStatus[]): string[] {
+  if (!servers.length) return ["  (no MCP servers — add one with /mcp add <name> npx -y <server> …)"];
+  return servers.map((s) =>
+    `  ${statusIcon(s.status)} ${s.name} [${s.kind}] ${s.status}` +
+    (s.status === "connected" ? ` · ${s.toolCount} tool(s)` : "") +
+    (s.error ? ` · ${s.error}` : ""));
+}
+
+// ---- /kb parsing (pure; the async handler lives in App.tsx) ---------------------------------------
+
+export interface KbFilter { ids?: string[]; kind?: string; sourcePrefix?: string }
+export type KbCommand =
+  | { kind: "sync" }
+  | { kind: "reindex" }
+  | { kind: "list"; filter: KbFilter }
+  | { kind: "forget"; filter: KbFilter }
+  | { kind: "error"; message: string };
+
+/** Parse `kind=…`, `source=…` (→ sourcePrefix), and repeatable `id=…` tokens into a filter. */
+function parseKbFilter(tokens: string[]): KbFilter {
+  const filter: KbFilter = {};
+  const ids: string[] = [];
+  for (const tok of tokens) {
+    const [k, ...rest] = tok.split("=");
+    const v = rest.join("=");
+    if (!v) continue;
+    if (k === "kind") filter.kind = v;
+    else if (k === "source") filter.sourcePrefix = v;
+    else if (k === "id") ids.push(v);
+  }
+  if (ids.length) filter.ids = ids;
+  return filter;
+}
+
+export function parseKbCommand(arg: string): KbCommand {
+  const parts = arg.trim().split(/\s+/).filter(Boolean);
+  const sub = parts[0];
+  const rest = parts.slice(1);
+  if (sub === "sync") return { kind: "sync" };
+  if (sub === "reindex") return { kind: "reindex" };
+  if (sub === "list") return { kind: "list", filter: parseKbFilter(rest) };
+  if (sub === "forget") {
+    const filter = parseKbFilter(rest);
+    if (!filter.ids && !filter.kind && !filter.sourcePrefix)
+      return { kind: "error", message: "usage: /kb forget kind=… | source=… | id=… (at least one)" };
+    return { kind: "forget", filter };
+  }
+  return { kind: "error", message: `unknown /kb subcommand "${sub ?? ""}" (try sync, list, forget, reindex)` };
+}
+
+// ---- /skills parsing (pure; the async handler lives in App.tsx) -----------------------------------
+
+export type SkillCommand =
+  | { kind: "list" }
+  | { kind: "reindex" }
+  | { kind: "show"; arg: string }
+  | { kind: "remove"; id: string }
+  | { kind: "error"; message: string };
+
+export function parseSkillCommand(arg: string): SkillCommand {
+  const parts = arg.trim().split(/\s+/).filter(Boolean);
+  const sub = parts[0];
+  if (!sub || sub === "list") return { kind: "list" };
+  if (sub === "reindex") return { kind: "reindex" };
+  if (sub === "show") return parts[1] ? { kind: "show", arg: parts[1] } : { kind: "error", message: "usage: /skills show <id|name>" };
+  if (sub === "remove") return parts[1] ? { kind: "remove", id: parts[1] } : { kind: "error", message: "usage: /skills remove <id>" };
+  return { kind: "error", message: `unknown /skills subcommand "${sub}" (try list, show, remove, reindex)` };
+}
+// Plan 21 Ph4: parseArtifactsCommand + ArtifactsCommand retired — /artifacts opens the browser;
+// the verbs live inside it (⏎ read · a annotate · y approve · v versions · o $EDITOR · g gc).

package/src/ui/text-buffer.ts

@@ -0,0 +1,92 @@
+/** Plan 24: pure cursor/edit model for the message buffer (may contain `\n` — see the multi-line section
+ *  at the bottom). `cursor` is a code-unit index in [0, value.length]. The word-boundary algorithm
+ *  (wordLeftIndex/wordRightIndex) is the heart of the
+ *  Option/Alt word-nav: skip whitespace in the direction of travel, then skip the maximal run of
+ *  same-CLASS chars (a run of word chars, or a run of non-space non-word chars). That matches how most
+ *  editors stop at punctuation. No Ink, no React — fully unit-testable. */
+export interface Buf { value: string; cursor: number }
+
+const WORD = /[\p{L}\p{N}_]/u;
+const isWord = (ch: string): boolean => WORD.test(ch);
+const isSpace = (ch: string): boolean => ch === " " || ch === "\t";
+
+export function insert(b: Buf, s: string): Buf {
+  return { value: b.value.slice(0, b.cursor) + s + b.value.slice(b.cursor), cursor: b.cursor + s.length };
+}
+export function backspace(b: Buf): Buf {
+  if (b.cursor === 0) return b;
+  return { value: b.value.slice(0, b.cursor - 1) + b.value.slice(b.cursor), cursor: b.cursor - 1 };
+}
+export function del(b: Buf): Buf {
+  if (b.cursor >= b.value.length) return b;
+  return { value: b.value.slice(0, b.cursor) + b.value.slice(b.cursor + 1), cursor: b.cursor };
+}
+export const left = (b: Buf): Buf => ({ ...b, cursor: Math.max(0, b.cursor - 1) });
+export const right = (b: Buf): Buf => ({ ...b, cursor: Math.min(b.value.length, b.cursor + 1) });
+export const home = (b: Buf): Buf => ({ ...b, cursor: 0 });
+export const end = (b: Buf): Buf => ({ ...b, cursor: b.value.length });
+
+export function wordLeftIndex(value: string, cursor: number): number {
+  let i = cursor;
+  while (i > 0 && isSpace(value[i - 1]!)) i--;
+  if (i === 0) return 0;
+  const cls = isWord(value[i - 1]!);
+  while (i > 0 && !isSpace(value[i - 1]!) && isWord(value[i - 1]!) === cls) i--;
+  return i;
+}
+export function wordRightIndex(value: string, cursor: number): number {
+  const n = value.length;
+  let i = cursor;
+  while (i < n && isSpace(value[i]!)) i++;
+  if (i === n) return n;
+  const cls = isWord(value[i]!);
+  while (i < n && !isSpace(value[i]!) && isWord(value[i]!) === cls) i++;
+  return i;
+}
+export const wordLeft = (b: Buf): Buf => ({ ...b, cursor: wordLeftIndex(b.value, b.cursor) });
+export const wordRight = (b: Buf): Buf => ({ ...b, cursor: wordRightIndex(b.value, b.cursor) });
+export function deleteWordBack(b: Buf): Buf {
+  const j = wordLeftIndex(b.value, b.cursor);
+  return { value: b.value.slice(0, j) + b.value.slice(b.cursor), cursor: j };
+}
+export function deleteWordForward(b: Buf): Buf {
+  const j = wordRightIndex(b.value, b.cursor);
+  return { value: b.value.slice(0, b.cursor) + b.value.slice(j), cursor: b.cursor };
+}
+
+// ── multi-line (Plan 24) — line motion for ↑/↓ inside a message with newlines ────────────────────
+
+/** Start index of the line the cursor is on (0, or one past the previous newline). */
+function lineStart(value: string, cursor: number): number {
+  return value.lastIndexOf("\n", cursor - 1) + 1;
+}
+/** End index of the line the cursor is on (the next newline, or end of value). */
+function lineEnd(value: string, cursor: number): number {
+  const nl = value.indexOf("\n", cursor);
+  return nl === -1 ? value.length : nl;
+}
+export function isOnFirstLine(value: string, cursor: number): boolean {
+  return value.lastIndexOf("\n", cursor - 1) === -1;
+}
+export function isOnLastLine(value: string, cursor: number): boolean {
+  return value.indexOf("\n", cursor) === -1;
+}
+
+/** Move the cursor up one line, keeping its column (clamped to the shorter line). No-op on the first line. */
+export function lineUp(b: Buf): Buf {
+  const start = lineStart(b.value, b.cursor);
+  if (start === 0) return b;
+  const col = b.cursor - start;
+  const prevStart = lineStart(b.value, start - 1);
+  const prevLen = start - 1 - prevStart; // chars on the previous line (excluding its trailing \n)
+  return { ...b, cursor: prevStart + Math.min(col, prevLen) };
+}
+/** Move the cursor down one line, keeping its column. No-op on the last line. */
+export function lineDown(b: Buf): Buf {
+  const end = lineEnd(b.value, b.cursor);
+  if (end === b.value.length) return b;
+  const col = b.cursor - lineStart(b.value, b.cursor);
+  const nextStart = end + 1;
+  const nextLen = lineEnd(b.value, nextStart) - nextStart;
+  return { ...b, cursor: nextStart + Math.min(col, nextLen) };
+}

package/src/ui/transcript-hydrate.ts

@@ -0,0 +1,51 @@
+/** Boot hydration: turn the replayed conversation thread — the SAME `rootThread` the model receives on
+ *  startup — into visible scrollback, so a resumed session opens on its history instead of a blank
+ *  screen. Pure + tested; App seeds `lines` from this at boot. What you SEE matches what the model
+ *  REMEMBERS: the replay is compacted (Plan 05 Ph3), so folded older turns arrive as one condensed
+ *  marker rather than verbatim. */
+import type { ModelMessage } from "ai";
+import type { Line } from "./slash";
+
+// The pinned summary head the replay cache leads with once older turns were folded (see store/thread.ts).
+const COMPACTION_HEAD_MARKER = "[CONVERSATION COMPACTION]";
+
+/** Flatten a message's content to plain text. A replayed turn is usually a string; be defensive about
+ *  the structured content-part form (extract the text parts, ignore the rest). */
+function textOf(content: ModelMessage["content"]): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part && typeof (part as { text?: unknown }).text === "string") {
+          return (part as { text: string }).text;
+        }
+        return "";
+      })
+      .join("");
+  }
+  return "";
+}
+
+/** Map the replay thread to scrollback lines: the compaction head becomes a "condensed" marker, user and
+ *  assistant turns become their normal lines, bracketed by a `resumed` header and a closing rule so the
+ *  prior conversation reads as clearly distinct from the live session below it. Empty in → empty out
+ *  (a fresh conversation hydrates nothing). */
+export function threadToLines(messages: ModelMessage[]): Line[] {
+  const body: Line[] = [];
+  let condensed = false;
+  for (const m of messages) {
+    const text = textOf(m.content).trim();
+    if (!text) continue;
+    if (m.role === "user") {
+      if (text.startsWith(COMPACTION_HEAD_MARKER)) { condensed = true; continue; } // the pinned summary head
+      body.push({ kind: "user", text });
+    } else if (m.role === "assistant") {
+      body.push({ kind: "agent", from: "root", text, rendered: true });
+    }
+    // system / tool roles were never part of the visible conversation — skip them
+  }
+  if (body.length === 0) return [];
+  const header = condensed ? "  ↩ resumed conversation · earlier turns condensed" : "  ↩ resumed conversation";
+  return [{ kind: "system", text: header }, ...body, { kind: "system", text: "  ───────────────" }];
+}

package/src/ui/transcript-style.ts

@@ -0,0 +1,124 @@
+/** Scrollback readability (transcript hierarchy). Pure helpers that decide how a `Line` is spaced and
+ *  coloured so the REPL reads as distinct turns instead of a low-contrast wall. Three tiers:
+ *
+ *    content   the user's turn (a full-width inverse ` you ` bar) and agent replies (a bold speaker).
+ *    activity  operation breadcrumbs (tool calls, delegations) — a dim `│` rail; routine ops recede.
+ *    problems  warnings / refusals / failures — coloured and NEVER dim, so they can't hide in the noise.
+ *
+ *  Kept pure + separate from App.tsx so the spacing/colour rules are unit-testable (Ink strips styling
+ *  from the test frame, but these decisions are plain data). */
+import type { Line } from "./slash";
+
+/** Which logical block a scrollback line belongs to. Consecutive lines in the same group are ONE block
+ *  (an agent reply is several rendered markdown blocks that share a speaker); a group change is a
+ *  turn/speaker/op-stream boundary that earns a blank line above it. */
+export function lineGroup(l: Line): string {
+  if (l.kind === "agent") return `agent:${l.from ?? ""}`;
+  return l.kind; // "user" | "system"
+}
+
+/** Blank line above a line: 1 when it OPENS a new block (a turn, a new speaker, or the start of an op
+ *  stream), and also between the paragraphs of one agent reply so a long answer breathes. 0 keeps a run
+ *  of operation breadcrumbs tight, so they read as a single column rather than sprawling. */
+export function marginTopFor(prev: Line | undefined, l: Line): 0 | 1 {
+  if (!prev) return 0;
+  if (lineGroup(prev) !== lineGroup(l)) return 1; // block boundary
+  return l.kind === "agent" ? 1 : 0; // same-reply paragraph spacing; op streams stay tight
+}
+
+export interface SpacedLine {
+  line: Line;
+  marginTop: 0 | 1;
+  /** True when this line opens a new block — used to show a speaker label once per agent reply. */
+  newBlock: boolean;
+}
+
+/** Precompute each line's spacing + block-boundary flag from its predecessor, so a write-once renderer
+ *  (Ink `<Static>`, whose callback sees one item at a time with no neighbours) needs no lookup. Prior
+ *  lines are frozen, so appending a line never changes an earlier line's result — safe for the log. */
+export function annotateSpacing(lines: Line[]): SpacedLine[] {
+  return lines.map((line, i) => {
+    const prev = lines[i - 1];
+    return { line, marginTop: marginTopFor(prev, line), newBlock: !prev || lineGroup(prev) !== lineGroup(line) };
+  });
+}
+
+export interface SystemLineStyle {
+  /** True for an activity breadcrumb (tool call, delegation, warning…) — it gets the `│` rail. False
+   *  for a plain notice (boot message, run summary), which renders flush with no rail. */
+  isOp: boolean;
+  /** Ink colour name; undefined = default foreground. */
+  color?: string;
+  dim: boolean;
+  /** Text to display: op lines are left-trimmed (the rail supplies the indent); notices are verbatim. */
+  text: string;
+}
+
+interface GlyphStyle {
+  color?: string;
+  dim: boolean;
+}
+
+// Leading glyph → treatment. Problems are bright (never dim) so they surface; routine tool activity
+// recedes to dim gray; a delegation keeps a dim magenta tint so it stays scannable amid the tool stream.
+const GLYPH_STYLES: Record<string, GlyphStyle> = {
+  "⚠": { color: "yellow", dim: false }, // warning / failure — must stay visible
+  "⊘": { color: "red", dim: false }, // refused
+  "✗": { color: "red", dim: false }, // failed
+  "⇢": { color: "magenta", dim: true }, // dispatch / delegation
+  "↳": { color: "gray", dim: true }, // tool breadcrumb — routine, recede hard
+  "✓": { color: "green", dim: true }, // success
+  "⊗": { color: "yellow", dim: true }, // cancelling
+  "⏰": { color: "blue", dim: true }, // schedule fired
+};
+
+/** Classify a `kind: "system"` line by its leading activity glyph. A line with no known glyph is a
+ *  plain notice (kept as the previous medium-gray). The glyph itself is left IN the text — the colour
+ *  categorises it, the rail groups it. */
+export function classifySystemLine(text: string): SystemLineStyle {
+  const trimmed = text.replace(/^\s+/, "");
+  for (const glyph in GLYPH_STYLES) {
+    if (trimmed.startsWith(glyph)) {
+      const s = GLYPH_STYLES[glyph];
+      return { isOp: true, color: s.color, dim: s.dim, text: trimmed };
+    }
+  }
+  return { isOp: false, color: "gray", dim: false, text };
+}
+
+const USER_BAR_LABEL = " you  ";
+
+/** Greedy word-wrap to `width` columns; a word longer than a line is hard-split so nothing overflows.
+ *  Always returns at least one line (an empty string for empty input). */
+export function wrapText(text: string, width: number): string[] {
+  const w = Math.max(1, width);
+  const lines: string[] = [];
+  for (const para of text.split("\n")) {
+    let cur = "";
+    for (let word of para.split(" ")) {
+      while (word.length > w) {
+        if (cur) { lines.push(cur); cur = ""; }
+        lines.push(word.slice(0, w));
+        word = word.slice(w);
+      }
+      if (cur === "") cur = word;
+      else if (cur.length + 1 + word.length <= w) cur += " " + word;
+      else { lines.push(cur); cur = word; }
+    }
+    lines.push(cur);
+  }
+  return lines.length ? lines : [""];
+}
+
+/** The user's turn as a FULL-WIDTH highlight bar: a ` you ` label on the first line, the message wrapped
+ *  and aligned under it, every line padded to `width` so an inverse render fills the row edge-to-edge
+ *  (an inverse `<Text>` only paints the characters it's given — the padding is what makes the bar solid). */
+export function userBarLines(text: string, width: number): string[] {
+  const label = USER_BAR_LABEL;
+  const indent = " ".repeat(label.length);
+  const w = Math.max(label.length + 1, width);
+  const body = wrapText(text, w - label.length);
+  return body
+    .map((ln, i) => (i === 0 ? label : indent) + ln)
+    .map((ln) => (ln.length >= w ? ln.slice(0, w) : ln.padEnd(w)));
+}

package/src/ui/workflow-browser-model.ts

@@ -0,0 +1,65 @@
+/** Plan 25: the /workflows browser's PURE model — the rows each screen renders, read from the stores.
+ *  No Ink here, so it's unit-testable (mirrors org-browser-model.ts). The component renders these. */
+import { listTeams } from "@taicho-ai/framework/store/teams";
+import { DEFAULT_TEAM_ID } from "@taicho-ai/contracts/team";
+import { loadWorkflowDef, loadWorkflow } from "@taicho-ai/framework/store/workflows";
+import { listWorkflowRunIds, foldWorkflowRun } from "@taicho-ai/graph";
+import type { WorkflowDef } from "@taicho-ai/graph";
+
+export type WorkflowKind = "structured" | "prose" | "none";
+
+export interface WorkflowRow {
+  team: string;
+  kind: WorkflowKind;
+  name?: string; // structured: the workflow name (def.id)
+  steps: number; // structured: step count · prose: seat count · none: 0
+  gates: number; // structured: human-gate count
+  runs: number; // past run count
+  lastStatus?: string; // last run's overall status
+}
+
+/** Run ids are `wr_<wf>_<n>`; sort by the numeric suffix (a lexical sort mis-orders _10 before _2). */
+const runNumber = (id: string): number => Number(/_(\d+)$/.exec(id)?.[1] ?? 0);
+
+/** One row per team (excluding `default`), classifying its workflow and summarizing its runs. */
+export function listWorkflowRows(ws: string): WorkflowRow[] {
+  return listTeams(ws)
+    .filter((t) => t.id !== DEFAULT_TEAM_ID)
+    .map((t): WorkflowRow => {
+      const def = loadWorkflowDef(ws, t.id);
+      if (def) {
+        const runIds = listWorkflowRunIds(ws, def.id).sort((a, b) => runNumber(a) - runNumber(b));
+        const last = runIds.length ? foldWorkflowRun(ws, def, runIds[runIds.length - 1]!) : null;
+        return {
+          team: t.id,
+          kind: "structured",
+          name: def.id,
+          steps: def.steps.length,
+          gates: def.steps.filter((s) => s.kind === "human").length,
+          runs: runIds.length,
+          lastStatus: last?.status,
+        };
+      }
+      const prose = loadWorkflow(ws, t.id);
+      if (prose) return { team: t.id, kind: "prose", steps: prose.sections.size, gates: 0, runs: 0 };
+      return { team: t.id, kind: "none", steps: 0, gates: 0, runs: 0 };
+    })
+    .sort((a, b) => a.team.localeCompare(b.team));
+}
+
+export interface RunRow {
+  runId: string;
+  status: string;
+  done: number;
+  total: number;
+}
+
+/** Past runs of a workflow, newest-first, with folded status + counts. */
+export function workflowRunRows(ws: string, def: WorkflowDef): RunRow[] {
+  return listWorkflowRunIds(ws, def.id)
+    .sort((a, b) => runNumber(b) - runNumber(a)) // newest first
+    .map((runId): RunRow => {
+      const s = foldWorkflowRun(ws, def, runId);
+      return { runId, status: s.status, done: s.counts.done, total: s.counts.total };
+    });
+}