projectinator 0.3.0 → 0.4.0

package/src/tui/BakeOff.tsx

@@ -1,190 +0,0 @@
-// Model bake-off — run one task across models, judge quality, compare cost, and
-// optionally save the winner as the model for that role. The founding idea, in
-// the cockpit. v1 covers text roles (design, plan, test-reasoning).
-
-import React, { useState } from "react";
-import { Box, Text } from "ink";
-import { Spinner, StatusMessage } from "@inkjs/ui";
-import { C, Panel, Menu as SelectInput, KeyHint, TextField as TextInput } from "./components.js";
-import { setRoleModel, modelLabel } from "./engine.js";
-import { runBakeoff, bakeoffTask, type BakeoffResult, type Candidate } from "../bakeoff.js";
-import type { Capability } from "../types.js";
-
-const CAPS: { label: string; value: Capability }[] = [
-  { label: "Design — spec / UI", value: "design" },
-  { label: "Plan — decompose / decide", value: "plan" },
-  { label: "Test — review reasoning", value: "test" },
-];
-
-const SAMPLE: Record<string, string> = {
-  design: "Design a pricing page with 3 tiers (Free, Pro, Team): layout, components, colors, states",
-  plan: "Plan an MVP task backlog for a URL shortener with analytics",
-  test: "Review this login flow spec and list the edge cases a tester must check",
-};
-
-// v1 compares the three Claude tiers (what most people hold a key for).
-const DEFAULT_CANDIDATES: Candidate[] = [
-  { provider: "anthropic", model: "claude-opus-4-8" },
-  { provider: "anthropic", model: "claude-sonnet-4-6" },
-  { provider: "anthropic", model: "claude-haiku-4-5" },
-];
-
-type View =
-  | { kind: "pickCap" }
-  | { kind: "enterTask" }
-  | { kind: "running" }
-  | { kind: "results"; result: BakeoffResult }
-  | { kind: "error"; msg: string };
-
-export function BakeOff({ onExit }: { onExit: () => void }): React.ReactElement {
-  const [cap, setCap] = useState<Capability>("design");
-  const [task, setTask] = useState("");
-  const [view, setView] = useState<View>({ kind: "pickCap" });
-  const [log, setLog] = useState<string[]>([]);
-  const [notice, setNotice] = useState("");
-
-  const start = (prompt: string) => {
-    setLog([]);
-    setNotice("");
-    setView({ kind: "running" });
-    runBakeoff(bakeoffTask(prompt, cap), DEFAULT_CANDIDATES, {
-      onProgress: (m) => setLog((prev) => [...prev.slice(-30), m]),
-    })
-      .then((result) => setView({ kind: "results", result }))
-      .catch((e) => setView({ kind: "error", msg: e instanceof Error ? e.message : String(e) }));
-  };
-
-  // ---------- pick capability ----------
-  if (view.kind === "pickCap") {
-    return (
-      <Box flexDirection="column">
-        <Panel title="Model bake-off">
-          <Box flexDirection="column" marginBottom={1}>
-            <Text color={C.dim}>Run one task across the three Claude tiers, judge quality,</Text>
-            <Text color={C.dim}>and compare cost + speed. Save the winner as that role's model.</Text>
-          </Box>
-          <SelectInput
-            items={[...CAPS, { label: "Back", value: "__back" }]}
-            onSelect={(i) => {
-              if (i.value === "__back") return onExit();
-              setCap(i.value as Capability);
-              setTask(SAMPLE[i.value] ?? "");
-              setView({ kind: "enterTask" });
-            }}
-          />
-        </Panel>
-      </Box>
-    );
-  }
-
-  // ---------- enter the task ----------
-  if (view.kind === "enterTask") {
-    return (
-      <Box flexDirection="column">
-        <Panel title={`Bake-off task — ${cap}`}>
-          <Text color={C.textMuted}>Edit the task, then run it across Opus / Sonnet / Haiku.</Text>
-          <Box marginTop={1}>
-            <Text color={C.accent}>{"› "}</Text>
-            <TextInput
-              value={task}
-              onChange={setTask}
-              onSubmit={() => { if (task.trim()) start(task.trim()); else setView({ kind: "pickCap" }); }}
-            />
-          </Box>
-          <Box flexDirection="column" marginTop={1}>
-            <KeyHint hints={[{ keys: "Enter", label: "run" }]} />
-            <Text color={C.textSubtle}>Clear the text and press Enter to cancel.</Text>
-          </Box>
-        </Panel>
-      </Box>
-    );
-  }
-
-  // ---------- running ----------
-  if (view.kind === "running") {
-    return (
-      <Box flexDirection="column">
-        <Panel title={`Running bake-off — ${cap}`}>
-          <Spinner label="Running each model, then judging (real spend)…" />
-          <Box marginTop={1} flexDirection="column">
-            {log.slice(-8).map((l, i) => <Text key={i} color={C.textSubtle} wrap="truncate-end">{l}</Text>)}
-          </Box>
-        </Panel>
-      </Box>
-    );
-  }
-
-  // ---------- error ----------
-  if (view.kind === "error") {
-    return (
-      <Box flexDirection="column">
-        <Panel title="Bake-off failed" borderColor={C.bad}>
-          <StatusMessage variant="error">{view.msg}</StatusMessage>
-          <Box marginTop={1}>
-            <SelectInput items={[{ label: "Back", value: "back" }]} onSelect={() => setView({ kind: "pickCap" })} />
-          </Box>
-        </Panel>
-      </Box>
-    );
-  }
-
-  // ---------- results ----------
-  const { result } = view;
-  const scoreOf = new Map(result.scores.map((s) => [s.model, s]));
-  const cheapest = result.entries.filter((e) => !e.error).sort((a, b) => a.cost - b.cost)[0];
-  const winnerModel = result.winner?.split("/")[1];
-  return (
-    <Box flexDirection="column">
-      {notice ? <Box marginBottom={1}><StatusMessage variant="success">{notice}</StatusMessage></Box> : null}
-      <Panel title={`Bake-off results — ${cap}`}>
-      <Box flexDirection="column">
-        <Text color={C.textSubtle}>{"model".padEnd(22)}{"score".padEnd(7)}{"cost".padEnd(11)}{"time".padEnd(7)}tok</Text>
-        {result.entries.map((e) => {
-          const key = `${e.provider}/${e.model}`;
-          const sc = scoreOf.get(key);
-          const win = key === result.winner;
-          return (
-            <Text key={key} color={win ? C.accent : e.error ? C.warn : C.text}>
-              {(win ? "🏆 " : "   ") + modelLabel(e.model)}
-              {"  "}
-              {(e.error ? "ERR" : sc ? `${sc.score}/10` : "—").padEnd(7)}
-              {(e.error ? "—" : `$${e.cost.toFixed(4)}`).padEnd(11)}
-              {(e.error ? "—" : `${(e.ms / 1000).toFixed(1)}s`).padEnd(7)}
-              {e.error ? "" : String(e.outputTokens)}
-            </Text>
-          );
-        })}
-      </Box>
-      {result.winner ? (
-        <Box marginTop={1} flexDirection="column">
-          <Text color={C.dim}>🏆 Best quality: {modelLabel(winnerModel ?? "")}  ·  💸 Cheapest: {cheapest ? modelLabel(cheapest.model) : "—"}  (judge: {modelLabel(result.judge?.split("/")[1] ?? "")})</Text>
-          {result.scores.sort((a, b) => b.score - a.score).map((s) => (
-            <Text key={s.model} color={C.dim} wrap="truncate-end">  {s.score}/10 {modelLabel(s.model.split("/")[1] ?? s.model)} — {s.reason}</Text>
-          ))}
-        </Box>
-      ) : (
-        <Box marginTop={1}><Text color={C.warn}>No winner (need ≥2 valid outputs to judge).</Text></Box>
-      )}
-      <Box marginTop={1}>
-        <SelectInput
-          items={[
-            ...(winnerModel ? [{ label: `Use ${modelLabel(winnerModel)} for all ${cap} tasks`, value: "save" }] : []),
-            { label: "Run another", value: "again" },
-            { label: "Back", value: "back" },
-          ]}
-          onSelect={(i) => {
-            if (i.value === "save" && winnerModel) {
-              setRoleModel(cap, "high", winnerModel);
-              setNotice(`Saved: ${cap} → ${modelLabel(winnerModel)} (all tiers).`);
-            } else if (i.value === "again") {
-              setView({ kind: "pickCap" });
-            } else {
-              onExit();
-            }
-          }}
-        />
-      </Box>
-      </Panel>
-    </Box>
-  );
-}

package/src/tui/BoardEditor.tsx

@@ -1,260 +0,0 @@
-// Interactive planning board with swimlanes (rows = epics). The PM curates before
-// building: pull cards Backlog⇄Ready, add/edit/delete, and break an epic down into
-// more tasks on demand. In Progress / Done fill during the build.
-
-import React, { useState } from "react";
-import { Box, Text, useInput } from "ink";
-import { Spinner } from "@inkjs/ui";
-import type { Capability, Difficulty, Task } from "../types.js";
-import { C, KeyHint, TextField as TextInput } from "./components.js";
-import { cleanDeps } from "./engine.js";
-import { estimateTokens } from "../estimate.js";
-import { groupByEpic } from "./Kanban.js";
-
-const CAPS: Capability[] = ["plan", "design", "code", "review", "test", "ops"]
-const DIFFS: Difficulty[] = ["trivial", "low", "medium", "high"];
-
-interface Card extends Task {
-  parked: boolean;
-}
-
-export function BoardEditor({
-  tasks,
-  onDone,
-  onCancel,
-  onBreakdown,
-}: {
-  tasks: Task[];
-  onDone: (readyTasks: Task[]) => void;
-  onCancel: () => void;
-  /** Break an epic into more tasks (calls the PM). Returns new tasks tagged with the epic. */
-  onBreakdown?: (epic: string, current: Task[]) => Promise<Task[]>;
-}): React.ReactElement {
-  // New tasks land in the BACKLOG first (Scrum-style); pull into Ready to build them.
-  const [items, setItems] = useState<Card[]>(() => tasks.map((t) => ({ ...t, parked: true })));
-  const [cursor, setCursor] = useState(0);
-  const [editing, setEditing] = useState(false);
-  const [editField, setEditField] = useState<"title" | "epic" | "deps" | "notes">("title");
-  const [draft, setDraft] = useState("");
-  const [warn, setWarn] = useState("");
-  const [busy, setBusy] = useState<string>(""); // epic being broken down
-
-  const lanes = groupByEpic(items);
-  const ordered = lanes.flatMap((l) => l.tasks); // flat cursor order (grouped by epic)
-  const selected = ordered[Math.min(cursor, ordered.length - 1)];
-
-  const update = (id: string, patch: Partial<Card>) =>
-    setItems((is) => is.map((c) => (c.id === id ? { ...c, ...patch } : c)));
-
-  const setAllParked = (parked: boolean) => {
-    setItems((is) => is.map((c) => ({ ...c, parked })));
-    setWarn("");
-  };
-
-  const nextId = () => {
-    const ids = new Set(items.map((c) => c.id));
-    let n = items.length + 1;
-    let id = `T-${String(n).padStart(2, "0")}`;
-    while (ids.has(id)) id = `T-${String(++n).padStart(2, "0")}`;
-    return id;
-  };
-
-  const finish = () => {
-    const ready = items.filter((c) => !c.parked);
-    if (ready.length === 0) {
-      setWarn("Nothing in Ready yet. Move tasks with → , or press A to pull the whole backlog.");
-      return;
-    }
-    onDone(cleanDeps(ready.map(({ parked, ...t }) => t as Task)));
-  };
-
-  const breakdown = async (epic: string) => {
-    if (!onBreakdown || busy) return;
-    setBusy(epic);
-    setWarn("");
-    try {
-      const created = await onBreakdown(epic, items.map(({ parked, ...t }) => t as Task));
-      const ids = new Set(items.map((c) => c.id));
-      const fresh = created.filter((t) => !ids.has(t.id)).map((t) => ({ ...t, epic: t.epic || epic, parked: true }));
-      setItems((is) => [...is, ...fresh]);
-    } catch {
-      setWarn("Couldn't break down that epic. Try again.");
-    } finally {
-      setBusy("");
-    }
-  };
-
-  // Reorder the selected card among its siblings (same epic + same column).
-  const reorder = (dir: -1 | 1) => {
-    if (!selected) return;
-    const idx = items.findIndex((c) => c.id === selected.id);
-    let j = idx + dir;
-    while (j >= 0 && j < items.length) {
-      if ((items[j]!.epic || "General") === (selected.epic || "General") && items[j]!.parked === selected.parked) break;
-      j += dir;
-    }
-    if (j < 0 || j >= items.length) return;
-    const next = [...items];
-    const [moved] = next.splice(idx, 1);
-    next.splice(j, 0, moved!);
-    setItems(next);
-    const newOrdered = groupByEpic(next).flatMap((l) => l.tasks);
-    setCursor(newOrdered.findIndex((c) => c.id === moved!.id));
-  };
-
-  useInput((input, key) => {
-    if (editing || busy) return;
-    if (key.upArrow) return setCursor((c) => Math.max(0, c - 1));
-    if (key.downArrow) return setCursor((c) => Math.min(ordered.length - 1, c + 1));
-    if (key.leftArrow) return selected && update(selected.id, { parked: true });
-    if (key.rightArrow) return selected && update(selected.id, { parked: false });
-    if (input === "[") return reorder(-1);
-    if (input === "]") return reorder(1);
-    if (input === "A") return setAllParked(false);
-    if (input === "Z") return setAllParked(true);
-    if (input === "a") {
-      const id = nextId();
-      const epic = selected?.epic || "General";
-      setItems((is) => [...is, { id, title: "New task", capability: "code", difficulty: "low", dependsOn: [], epic, estTokens: estimateTokens("code", "low"), parked: true }]);
-      setDraft("New task");
-      setEditing(true);
-      return;
-    }
-    if (!selected) return;
-    if (input === "b") return void breakdown(selected.epic || "General");
-    if (input === "e") {
-      setEditField("title");
-      setDraft(selected.title);
-      setEditing(true);
-    } else if (input === "g") {
-      setEditField("epic");
-      setDraft(selected.epic || "General");
-      setEditing(true);
-    } else if (input === "D") {
-      setEditField("deps");
-      setDraft((selected.dependsOn ?? []).join(" "));
-      setEditing(true);
-    } else if (input === "n") {
-      setEditField("notes");
-      setDraft(selected.notes ?? "");
-      setEditing(true);
-    } else if (input === "c") {
-      const cap = CAPS[(CAPS.indexOf(selected.capability) + 1) % CAPS.length]!;
-      update(selected.id, { capability: cap, estTokens: estimateTokens(cap, selected.difficulty) });
-    } else if (input === "f") {
-      const diff = DIFFS[(DIFFS.indexOf(selected.difficulty) + 1) % DIFFS.length]!;
-      update(selected.id, { difficulty: diff, estTokens: estimateTokens(selected.capability, diff) });
-    } else if (input === "d") {
-      setItems((is) => is.filter((c) => c.id !== selected.id));
-      setCursor((c) => Math.max(0, c - 1));
-    } else if (key.return) finish();
-    else if (key.escape) onCancel();
-  });
-
-  const readyCount = items.filter((c) => !c.parked).length;
-  const backlogCount = items.length - readyCount;
-
-  const Cell = ({ cards }: { cards: Card[] }) => (
-    <Box flexDirection="column" flexBasis="25%" flexGrow={1} marginRight={1}>
-      {cards.length === 0 ? <Text color={C.dim}>·</Text> : cards.map((c) => {
-        const sel = selected?.id === c.id;
-        return (
-          <Box key={c.id} flexDirection="column" marginBottom={1}>
-            <Box>
-              <Text color={C.accent}>{sel ? "› " : "  "}</Text>
-              <Text color={C.dim}>{c.id} </Text>
-              <Text color={C.accent}>{c.capability}/{c.difficulty}</Text>
-            </Box>
-            <Box>
-              <Text> </Text>
-              {sel && editing && editField === "title" ? (
-                <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(c.id, { title: draft.trim() || c.title }); setEditing(false); }} />
-              ) : (
-                <Text color={sel ? C.text : C.dim} wrap="truncate-end">{c.title}</Text>
-              )}
-            </Box>
-            {(c.dependsOn ?? []).length ? <Text color={C.dim}>  ↖ {(c.dependsOn ?? []).join(", ")}</Text> : null}
-            {c.notes ? <Text color={C.dim} wrap="truncate-end">  ✎ {c.notes}</Text> : null}
-          </Box>
-        );
-      })}
-    </Box>
-  );
-
-  return (
-    <Box flexDirection="column">
-      <Text bold>Plan board <Text color={C.dim}>({backlogCount} in backlog, {readyCount} ready to build)</Text></Text>
-      {warn ? <Text color={C.warn}>{warn}</Text> : null}
-      {busy ? <Spinner label={`Breaking down “${busy}”…`} /> : null}
-      {editing && editField === "epic" && selected ? (
-        <Box>
-          <Text color={C.accent}>Epic for {selected.id}: </Text>
-          <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(selected.id, { epic: draft.trim() || selected.epic }); setEditing(false); }} />
-        </Box>
-      ) : null}
-      {editing && editField === "deps" && selected ? (
-        <Box>
-          <Text color={C.accent}>{selected.id} depends on (space-separated ids): </Text>
-          <TextInput
-            value={draft}
-            onChange={setDraft}
-            onSubmit={() => {
-              const ids = new Set(items.map((c) => c.id));
-              const deps = draft.split(/[\s,]+/).filter((d) => d && d !== selected.id && ids.has(d));
-              update(selected.id, { dependsOn: [...new Set(deps)] });
-              setEditing(false);
-            }}
-          />
-        </Box>
-      ) : null}
-      {editing && editField === "notes" && selected ? (
-        <Box>
-          <Text color={C.accent}>Note for {selected.id} (yours only, never sent to the model): </Text>
-          <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(selected.id, { notes: draft.trim() || undefined }); setEditing(false); }} />
-        </Box>
-      ) : null}
-
-      {/* column headers */}
-      <Box marginTop={1}>
-        <Box width={12} />
-        <Box flexBasis="25%" flexGrow={1} marginRight={1}><Text color="cyan" bold>BACKLOG {backlogCount}</Text></Box>
-        <Box flexBasis="25%" flexGrow={1} marginRight={1}><Text color={C.accent} bold>READY {readyCount}</Text></Box>
-        <Box flexBasis="25%" flexGrow={1} marginRight={1}><Text color={C.dim} bold>IN PROGRESS</Text></Box>
-        <Box flexBasis="25%" flexGrow={1}><Text color={C.dim} bold>DONE</Text></Box>
-      </Box>
-
-      {lanes.map((lane) => (
-        <Box key={lane.epic} flexDirection="column" marginTop={1}>
-          <Text color={C.accent}>▊ {lane.epic}</Text>
-          <Box>
-            <Box width={12} />
-            <Cell cards={lane.tasks.filter((c) => c.parked)} />
-            <Cell cards={lane.tasks.filter((c) => !c.parked)} />
-            <Box flexBasis="25%" flexGrow={1} marginRight={1}><Text color={C.dim}>·</Text></Box>
-            <Box flexBasis="25%" flexGrow={1}><Text color={C.dim}>·</Text></Box>
-          </Box>
-        </Box>
-      ))}
-      <Box marginTop={1}>
-        <KeyHint hints={[
-          { keys: "↑↓", label: "pick" },
-          { keys: "→/←", label: "col" },
-          { keys: "[ ]", label: "reorder" },
-          { keys: "a", label: "add" },
-          { keys: "e", label: "edit" },
-          { keys: "g", label: "epic" },
-          { keys: "D", label: "deps" },
-          { keys: "n", label: "note" },
-          { keys: "c", label: "cap" },
-          { keys: "f", label: "diff" },
-          { keys: "b", label: "break" },
-          { keys: "d", label: "del" },
-          { keys: "A", label: "all" },
-          { keys: "Z", label: "none" },
-          { keys: "Enter", label: "build" },
-          { keys: "Esc", label: "back" },
-        ]} />
-      </Box>
-    </Box>
-  );
-}

package/src/tui/EditableBoard.tsx

@@ -1,179 +0,0 @@
-// Directly edit a project's board: reorganize epics, rename, retag, add or delete
-// tasks. Done tasks are locked (they're already built). Saves back to build-state.
-
-import React, { useState } from "react";
-import { Box, Text, useInput } from "ink";
-import type { Capability, Difficulty, Task } from "../types.js";
-import { C, ROLE_META, KeyHint, TextField as TextInput } from "./components.js";
-import { estimateTokens } from "../estimate.js";
-import { groupByEpic } from "./Kanban.js";
-
-const CAPS: Capability[] = ["plan", "design", "code", "review", "test", "ops"]
-const DIFFS: Difficulty[] = ["trivial", "low", "medium", "high"];
-
-export function EditableBoard({
-  tasks,
-  doneIds,
-  onSave,
-  onCancel,
-}: {
-  tasks: Task[];
-  doneIds: Set<string>;
-  onSave: (tasks: Task[]) => void;
-  onCancel: () => void;
-}): React.ReactElement {
-  const [items, setItems] = useState<Task[]>(() => tasks.map((t) => ({ ...t })));
-  const [cursor, setCursor] = useState(0);
-  const [editing, setEditing] = useState(false);
-  const [field, setField] = useState<"title" | "epic" | "deps" | "notes">("title");
-  const [draft, setDraft] = useState("");
-  const [warn, setWarn] = useState("");
-
-  const lanes = groupByEpic(items);
-  const ordered = lanes.flatMap((l) => l.tasks);
-  const selected = ordered[Math.min(cursor, ordered.length - 1)];
-  const isDone = (id: string) => doneIds.has(id);
-
-  const update = (id: string, patch: Partial<Task>) =>
-    setItems((is) => is.map((t) => (t.id === id ? { ...t, ...patch } : t)));
-
-  const nextId = () => {
-    const ids = new Set(items.map((t) => t.id));
-    let n = items.length + 1;
-    let id = `T-${String(n).padStart(2, "0")}`;
-    while (ids.has(id)) id = `T-${String(++n).padStart(2, "0")}`;
-    return id;
-  };
-
-  useInput((input, key) => {
-    if (editing) return;
-    if (key.upArrow) return setCursor((c) => Math.max(0, c - 1));
-    if (key.downArrow) return setCursor((c) => Math.min(ordered.length - 1, c + 1));
-    if (input === "[" || input === "]") {
-      if (!selected) return;
-      const dir = input === "[" ? -1 : 1;
-      const idx = items.findIndex((t) => t.id === selected.id);
-      let j = idx + dir;
-      while (j >= 0 && j < items.length) {
-        if ((items[j]!.epic || "General") === (selected.epic || "General")) break;
-        j += dir;
-      }
-      if (j < 0 || j >= items.length) return;
-      const next = [...items];
-      const [moved] = next.splice(idx, 1);
-      next.splice(j, 0, moved!);
-      setItems(next);
-      const newOrdered = groupByEpic(next).flatMap((l) => l.tasks);
-      setCursor(newOrdered.findIndex((t) => t.id === moved!.id));
-      return;
-    }
-    if (input === "a") {
-      const id = nextId();
-      const epic = selected?.epic || "General";
-      setItems((is) => [...is, { id, title: "New task", capability: "code", difficulty: "low", dependsOn: [], epic, estTokens: estimateTokens("code", "low") }]);
-      setField("title");
-      setDraft("New task");
-      setEditing(true);
-      setWarn("");
-      return;
-    }
-    if (!selected) return;
-    if (key.return) return onSave(items);
-    if (key.escape) return onCancel();
-    if (input === "g") { setField("epic"); setDraft(selected.epic || "General"); setEditing(true); return; }
-    if (input === "D") { setField("deps"); setDraft((selected.dependsOn ?? []).join(" ")); setEditing(true); return; }
-    if (input === "n") { setField("notes"); setDraft(selected.notes ?? ""); setEditing(true); return; }
-    // fields below don't change built work
-    if (isDone(selected.id)) {
-      setWarn(`${selected.id} is already built — only its epic (g) and notes (n) can be changed.`);
-      return;
-    }
-    if (input === "e") { setField("title"); setDraft(selected.title); setEditing(true); }
-    else if (input === "c") {
-      const cap = CAPS[(CAPS.indexOf(selected.capability) + 1) % CAPS.length]!;
-      update(selected.id, { capability: cap, estTokens: estimateTokens(cap, selected.difficulty) });
-    } else if (input === "f") {
-      const diff = DIFFS[(DIFFS.indexOf(selected.difficulty) + 1) % DIFFS.length]!;
-      update(selected.id, { difficulty: diff, estTokens: estimateTokens(selected.capability, diff) });
-    } else if (input === "d") {
-      setItems((is) => is.filter((t) => t.id !== selected.id));
-      setCursor((c) => Math.max(0, c - 1));
-    }
-  });
-
-  return (
-    <Box flexDirection="column">
-      <Text bold>Edit board <Text color={C.dim}>({items.length} tasks)</Text></Text>
-      {warn ? <Text color={C.warn}>{warn}</Text> : null}
-      {editing && field === "epic" && selected ? (
-        <Box><Text color={C.accent}>Epic for {selected.id}: </Text>
-          <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(selected.id, { epic: draft.trim() || selected.epic }); setEditing(false); }} />
-        </Box>
-      ) : null}
-      {editing && field === "deps" && selected ? (
-        <Box><Text color={C.accent}>{selected.id} depends on (ids): </Text>
-          <TextInput
-            value={draft}
-            onChange={setDraft}
-            onSubmit={() => {
-              const ids = new Set(items.map((t) => t.id));
-              const deps = draft.split(/[\s,]+/).filter((d) => d && d !== selected.id && ids.has(d));
-              update(selected.id, { dependsOn: [...new Set(deps)] });
-              setEditing(false);
-            }}
-          />
-        </Box>
-      ) : null}
-      {editing && field === "notes" && selected ? (
-        <Box><Text color={C.accent}>Note for {selected.id} (yours only, never sent to the model): </Text>
-          <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(selected.id, { notes: draft.trim() || undefined }); setEditing(false); }} />
-        </Box>
-      ) : null}
-
-      {lanes.map((lane) => (
-        <Box key={lane.epic} flexDirection="column" marginTop={1}>
-          <Text color={C.accent}>▊ {lane.epic}</Text>
-          {lane.tasks.map((t) => {
-            const sel = selected?.id === t.id;
-            const done = isDone(t.id);
-            return (
-              <Box key={t.id} flexDirection="column">
-                <Box>
-                  <Box width={2}><Text color={C.accent}>{sel ? "›" : " "}</Text></Box>
-                  <Box width={2}><Text color={done ? C.good : C.dim}>{done ? "✓" : "○"}</Text></Box>
-                  <Box width={7}><Text color={C.dim}>{t.id}</Text></Box>
-                  <Box width={3}><Text>{ROLE_META[t.capability].emoji}</Text></Box>
-                  <Box width={16}><Text color={sel ? C.accent : C.dim}>{t.capability}/{t.difficulty}</Text></Box>
-                  <Box flexGrow={1}>
-                    {sel && editing && field === "title" ? (
-                      <TextInput value={draft} onChange={setDraft} onSubmit={() => { update(t.id, { title: draft.trim() || t.title }); setEditing(false); }} />
-                    ) : (
-                      <Text color={sel ? C.text : done ? C.dim : C.text} wrap="truncate-end">{t.title}</Text>
-                    )}
-                  </Box>
-                </Box>
-                {t.notes ? <Box marginLeft={30}><Text color={C.dim} wrap="truncate-end">✎ {t.notes}</Text></Box> : null}
-              </Box>
-            );
-          })}
-        </Box>
-      ))}
-      <Box marginTop={1}>
-        <KeyHint hints={[
-          { keys: "↑↓", label: "pick" },
-          { keys: "[ ]", label: "reorder" },
-          { keys: "g", label: "epic" },
-          { keys: "D", label: "deps" },
-          { keys: "n", label: "note" },
-          { keys: "e", label: "rename" },
-          { keys: "c", label: "cap" },
-          { keys: "f", label: "diff" },
-          { keys: "a", label: "add" },
-          { keys: "d", label: "delete" },
-          { keys: "Enter", label: "save" },
-          { keys: "Esc", label: "back" },
-        ]} />
-      </Box>
-    </Box>
-  );
-}