schub 0.1.3 → 0.1.4

package/src/tui/components/StatusView.test.tsx

@@ -0,0 +1,1351 @@
+import { afterEach, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { render as inkRender } from "ink-testing-library";
+import StatusView from "./StatusView";
+import { buildShowAllTaskGroups } from "./status-view-data";
+import { StatusShowAllTasksView } from "./status-view-render";
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}[[0-9;]*m`, "g");
+const stripAnsi = (value: string) => value.replace(ansiPattern, "");
+const normalizeWhitespace = (value: string) => value.replace(/\s+/g, " ").trim();
+
+const extractSection = (output: string, start: string, end?: string): string => {
+  const startIndex = output.indexOf(start);
+  if (startIndex === -1) {
+    return "";
+  }
+
+  const afterStart = output.slice(startIndex + start.length);
+  if (!end) {
+    return afterStart;
+  }
+  const endIndex = afterStart.indexOf(end);
+  if (endIndex === -1) {
+    return afterStart;
+  }
+
+  return afterStart.slice(0, endIndex);
+};
+
+const renders: Array<() => void> = [];
+const render = (...args: Parameters<typeof inkRender>) => {
+  const rendered = inkRender(...args);
+  renders.push(rendered.unmount);
+  return rendered;
+};
+
+afterEach(() => {
+  for (const unmount of renders) {
+    unmount();
+  }
+  renders.length = 0;
+});
+
+const writeTask = (tasksRoot: string, id: string, slug: string, body: string) => {
+  const filePath = join(tasksRoot, `${id}_${slug}.md`);
+  writeFileSync(filePath, body, "utf8");
+};
+
+const writeProposal = (changesRoot: string, changeId: string, status: string, title = changeId) => {
+  const changeDir = join(changesRoot, changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), `---\nstatus: ${status}\n---\n# Proposal - ${title}\n`, "utf8");
+};
+
+const findLine = (output: string, id: string) => {
+  return output.split("\n").find((line) => line.includes(id)) ?? "";
+};
+
+const countOccurrences = (output: string, value: string) => output.split(value).length - 1;
+
+const hasSelectionMarker = (output: string, id: string, marker: string) => {
+  return output.split("\n").some((line) => line.includes(id) && line.includes(marker));
+};
+
+const changeDisplayId = (value: string) => value.split("_")[0];
+
+const noopCopy = () => {};
+
+const nextTick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+test("status view shows checklist indicator only for wip tasks", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-view-"));
+  const schubDir = join(base, ".schub");
+  const wipRoot = join(schubDir, "tasks", "wip");
+  const readyRoot = join(schubDir, "tasks", "ready");
+
+  mkdirSync(wipRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+
+  writeTask(wipRoot, "T0100", "wip-checklist", "# Task: T0100 Wip Checklist\n\n## Steps\n- [ ] First\n- [x] Second\n");
+  writeTask(wipRoot, "T0101", "wip-complete", "# Task: T0101 Wip Complete\n\n## Steps\n- [x] First\n- [x] Second\n");
+  writeTask(wipRoot, "T0102", "wip-empty", "# Task: T0102 Wip Empty\n\n## Steps\n- Do the thing\n");
+  writeTask(readyRoot, "T0200", "ready-checklist", "# Task: T0200 Ready Checklist\n\n## Steps\n- [ ] First\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    const wipChecklistLine = findLine(output, "T0100");
+    const wipCompleteLine = findLine(output, "T0101");
+    const wipEmptyLine = findLine(output, "T0102");
+    const readyLine = findLine(output, "T0200");
+
+    expect(wipChecklistLine).toContain("wip checklist");
+    expect(wipChecklistLine).toContain("(1/2)");
+    expect(wipCompleteLine).toContain("(0/2)");
+    expect(wipEmptyLine).toContain("wip empty");
+    expect(wipEmptyLine).not.toContain("wip empty (");
+    expect(readyLine).toContain("ready checklist");
+    expect(readyLine).not.toContain("ready checklist (");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows blocked reasons for blocked tasks", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-blocked-reason-"));
+  const schubDir = join(base, ".schub");
+  const blockedRoot = join(schubDir, "tasks", "blocked");
+
+  mkdirSync(blockedRoot, { recursive: true });
+
+  writeTask(
+    blockedRoot,
+    "T0600",
+    "blocked-task",
+    "---\nblocked_reason: Waiting on API\n---\n# Task: T0600 Blocked Task\n",
+  );
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const blockedLine = findLine(output, "T0600");
+
+    expect(blockedLine).toContain("Waiting on API");
+    expect(blockedLine).not.toContain("blocked task");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view omits blocked titles when reasons are missing", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-blocked-empty-"));
+  const schubDir = join(base, ".schub");
+  const blockedRoot = join(schubDir, "tasks", "blocked");
+
+  mkdirSync(blockedRoot, { recursive: true });
+
+  writeTask(blockedRoot, "T0601", "missing-reason", "# Task: T0601 Missing Reason\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const blockedLine = findLine(output, "T0601");
+
+    expect(blockedLine).not.toContain("missing reason");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view omits per-item shortcuts for tasks and proposals", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-actions-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const readyRoot = join(schubDir, "tasks", "ready");
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+
+  const changeId = "C0003_demo-change";
+  const displayId = changeDisplayId(changeId);
+
+  writeProposal(changesRoot, changeId, "Draft");
+  writeTask(readyRoot, "T0003", "ready-task", "# Task: T0003 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    expect(findLine(output, displayId)).not.toContain("[o preview]");
+    expect(findLine(output, displayId)).not.toContain("[c copy id]");
+    expect(findLine(output, "T0003")).not.toContain("[o preview]");
+    expect(findLine(output, "T0003")).not.toContain("[c copy id]");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows proposal titles", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-proposal-title-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeId = "C0004_pretty-proposals";
+  const changeTitle = "Pretty Print Change Proposals";
+  const displayId = changeDisplayId(changeId);
+
+  writeProposal(changesRoot, changeId, "Draft", changeTitle);
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const line = findLine(output, displayId);
+
+    expect(line).toContain(displayId);
+    expect(line).toContain(changeTitle);
+    expect(line).not.toContain(changeId);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view formats default proposal titles from ids", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-proposal-id-title-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeId = "C0001_pending-review-quick-action";
+  const displayId = changeDisplayId(changeId);
+
+  writeProposal(changesRoot, changeId, "Pending Review");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const line = findLine(output, displayId);
+
+    expect(line).toContain(displayId);
+    expect(line).toContain("Pending Review Quick Action");
+    expect(line).not.toContain("pending-review-quick-action");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view copies the selected id on c", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-copy-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  let copied = "";
+  const recordCopy = (id: string) => {
+    copied = id;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0010", "copy-task", "# Task: T0010 Copy Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={recordCopy} />);
+    rendered.stdin.write("c");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(copied).toBe("T0010");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens the selected item on o", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-open-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  let openedRoot = "";
+  let openedPath = "";
+  const recordOpen = (repoRoot: string, relativePath: string) => {
+    openedRoot = repoRoot;
+    openedPath = relativePath;
+  };
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0800", "preview-task", "---\ndepends_on:\n  - T9999\n---\n# Task: T0800 Preview Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onOpen={recordOpen} />);
+    await nextTick();
+    rendered.stdin.write("o");
+    await nextTick();
+    expect(realpathSync(openedRoot)).toBe(realpathSync(base));
+    expect(openedPath).toContain("tasks/backlog/T0800_preview-task.md");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view reports implement shortcut only for ready selections", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-implement-shortcut-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+  const blockedRoot = join(schubDir, "tasks", "blocked");
+  let shortcuts: { keyLabel: string; label: string }[] = [];
+  const recordShortcuts = (value: { keyLabel: string; label: string }[]) => {
+    shortcuts = value;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+  mkdirSync(blockedRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0508", "done-task", "# Task: T0508 Done Task\n");
+  writeTask(readyRoot, "T0509", "ready-task", "---\ndepends_on:\n  - T0508\n---\n# Task: T0509 Ready Task\n");
+  writeTask(blockedRoot, "T0510", "blocked-task", "---\nblocked_reason: Waiting\n---\n# Task: T0510 Blocked Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onShortcutsChange={recordShortcuts} />);
+    await nextTick();
+    await nextTick();
+    expect(shortcuts).toContainEqual({ keyLabel: "i", label: "implement" });
+
+    rendered.stdin.write("\u001B[B");
+    await nextTick();
+    await nextTick();
+    expect(shortcuts).not.toContainEqual({ keyLabel: "i", label: "implement" });
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view reports status shortcut for ready tasks", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-shortcut-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  let shortcuts: { keyLabel: string; label: string }[] = [];
+  const recordShortcuts = (value: { keyLabel: string; label: string }[]) => {
+    shortcuts = value;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0514", "ready-task", "# Task: T0514 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    render(<StatusView onCopyId={noopCopy} onShortcutsChange={recordShortcuts} />);
+    await nextTick();
+    await nextTick();
+    expect(shortcuts).toContainEqual({ keyLabel: "s", label: "status" });
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view reports status shortcut in tasks page", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-tasks-shortcut-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  let shortcuts: { keyLabel: string; label: string }[] = [];
+  const recordShortcuts = (value: { keyLabel: string; label: string }[]) => {
+    shortcuts = value;
+  };
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0515", "backlog-task", "# Task: T0515 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onShortcutsChange={recordShortcuts} />);
+    await nextTick();
+    rendered.stdin.write("t");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(shortcuts).toContainEqual({ keyLabel: "s", label: "status" });
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view ignores implement shortcut when selection is not ready", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-implement-ignore-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+  const blockedRoot = join(schubDir, "tasks", "blocked");
+  let didImplement = false;
+  const recordImplement = () => {
+    didImplement = true;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+  mkdirSync(blockedRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0511", "done-task", "# Task: T0511 Done Task\n");
+  writeTask(readyRoot, "T0512", "ready-task", "---\ndepends_on:\n  - T0511\n---\n# Task: T0512 Ready Task\n");
+  writeTask(blockedRoot, "T0513", "blocked-task", "---\nblocked_reason: Waiting\n---\n# Task: T0513 Blocked Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onImplement={recordImplement} />);
+    await nextTick();
+    rendered.stdin.write("\u001B[B");
+    await nextTick();
+    rendered.stdin.write("i");
+    await nextTick();
+    expect(didImplement).toBe(false);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view triggers implement on i for ready to implement tasks", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-implement-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+  let didImplement = false;
+  let implemented = { id: "", repoRoot: "" };
+  const recordImplement = (id: string, repoRoot: string) => {
+    implemented = { id, repoRoot };
+    didImplement = true;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0500", "done-task", "# Task: T0500 Done Task\n");
+  writeTask(readyRoot, "T0501", "ready-task", "---\ndepends_on:\n  - T0500\n---\n# Task: T0501 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onImplement={recordImplement} />);
+    rendered.stdin.write("i");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(didImplement).toBe(true);
+    expect(implemented.id).toBe("T0501");
+    expect(realpathSync(implemented.repoRoot)).toBe(realpathSync(base));
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens backlog status modal on s", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-backlog-modal-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0600", "backlog-task", "# Task: T0600 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    await nextTick();
+    rendered.stdin.write("s");
+    await nextTick();
+
+    const output = normalizeWhitespace(stripAnsi(rendered.lastFrame() ?? ""));
+
+    expect(output).toContain("› Ready");
+    expect(output).toContain("Archive");
+    expect(output).toContain("enter confirm");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view moves backlog task to ready from modal", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-backlog-ready-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const backlogFile = join(backlogRoot, "T0601_backlog-task.md");
+  const readyFile = join(readyRoot, "T0601_backlog-task.md");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0601", "backlog-task", "# Task: T0601 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    rendered.stdin.write("s");
+    await nextTick();
+    rendered.stdin.write("\n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(existsSync(readyFile)).toBe(true);
+    expect(existsSync(backlogFile)).toBe(false);
+
+    const output = stripAnsi(rendered.lastFrame() ?? "");
+    expect(output).not.toContain("Move backlog task");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view moves backlog task to archived from modal", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-backlog-archive-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const archiveRoot = join(schubDir, "tasks", "archived");
+  const backlogFile = join(backlogRoot, "T0602_backlog-task.md");
+  const archiveFile = join(archiveRoot, "T0602_backlog-task.md");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0602", "backlog-task", "# Task: T0602 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    await nextTick();
+    rendered.stdin.write("s");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    rendered.stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    rendered.stdin.write("\n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(existsSync(archiveFile)).toBe(true);
+    expect(existsSync(backlogFile)).toBe(false);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens ready status modal on s", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-modal-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0603", "ready-task", "# Task: T0603 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    await nextTick();
+    rendered.stdin.write("s");
+    await nextTick();
+
+    const output = normalizeWhitespace(stripAnsi(rendered.lastFrame() ?? ""));
+
+    expect(output).toContain("› Backlog");
+    expect(output).toContain("Archive");
+    expect(output).toContain("enter confirm");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view moves ready task to backlog from modal", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-backlog-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyFile = join(readyRoot, "T0604_ready-task.md");
+  const backlogFile = join(backlogRoot, "T0604_ready-task.md");
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0604", "ready-task", "# Task: T0604 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    rendered.stdin.write("s");
+    await nextTick();
+    rendered.stdin.write("\n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(existsSync(backlogFile)).toBe(true);
+    expect(existsSync(readyFile)).toBe(false);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view moves ready task to archived from modal", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-archive-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const archiveRoot = join(schubDir, "tasks", "archived");
+  const readyFile = join(readyRoot, "T0605_ready-task.md");
+  const archiveFile = join(archiveRoot, "T0605_ready-task.md");
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0605", "ready-task", "# Task: T0605 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    await nextTick();
+    rendered.stdin.write("s");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    rendered.stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    rendered.stdin.write("\n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    expect(existsSync(archiveFile)).toBe(true);
+    expect(existsSync(readyFile)).toBe(false);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view ignores status shortcut for non-ready tasks", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-non-ready-"));
+  const schubDir = join(base, ".schub");
+  const wipRoot = join(schubDir, "tasks", "wip");
+  const wipFile = join(wipRoot, "T0606_wip-task.md");
+
+  mkdirSync(wipRoot, { recursive: true });
+  writeTask(wipRoot, "T0606", "wip-task", "# Task: T0606 WIP Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    rendered.stdin.write("s");
+    await nextTick();
+
+    const output = normalizeWhitespace(stripAnsi(rendered.lastFrame() ?? ""));
+    expect(output).not.toContain("enter confirm");
+    expect(existsSync(wipFile)).toBe(true);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows pending implementation counts and no tasks defined section", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-proposals-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const doneRoot = join(schubDir, "tasks", "done");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeWithTasks = "C0001_with-tasks";
+  const changeNoTasks = "C0002_no-tasks";
+  const displayWithTasks = changeDisplayId(changeWithTasks);
+  const displayNoTasks = changeDisplayId(changeNoTasks);
+
+  writeProposal(changesRoot, changeWithTasks, "Accepted");
+  writeProposal(changesRoot, changeNoTasks, "Accepted");
+
+  writeTask(backlogRoot, "T0010", "first-task", `---\nchange_id: ${changeWithTasks}\n---\n# Task: T0010 First Task\n`);
+  writeTask(
+    backlogRoot,
+    "T0011",
+    "second-task",
+    `---\nchange_id: ${changeWithTasks}\n---\n# Task: T0011 Second Task\n`,
+  );
+  writeTask(doneRoot, "T0012", "done-task", `---\nchange_id: ${changeWithTasks}\n---\n# Task: T0012 Done Task\n`);
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    expect(output).toContain("No Tasks Defined");
+
+    const withTasksLine = findLine(output, displayWithTasks);
+    expect(withTasksLine).toContain("1/3");
+
+    const noTasksLine = findLine(output, displayNoTasks);
+    expect(noTasksLine).not.toContain("/");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view sorts ready to implement tasks alphabetically", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-sorted-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+  const blockedRoot = join(schubDir, "tasks", "blocked");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+  mkdirSync(blockedRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0400", "done-task", "# Task: T0400 Done Task\n");
+  writeTask(doneRoot, "T0401", "done-task-two", "# Task: T0401 Done Task Two\n");
+  writeTask(backlogRoot, "T0402", "zulu-task", "---\ndepends_on:\n  - T0400\n---\n# Task: T0402 Zulu Task\n");
+  writeTask(readyRoot, "T0403", "alpha-task", "---\ndepends_on:\n  - T0401\n---\n# Task: T0403 Alpha Task\n");
+  writeTask(blockedRoot, "T0404", "blocked-task", "---\nblocked_reason: Waiting\n---\n# Task: T0404 Blocked Task\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const readySection = extractSection(output, "Ready to Implement", "Blocked");
+    const alphaIndex = readySection.indexOf("alpha task");
+    const zuluIndex = readySection.indexOf("zulu task");
+
+    expect(alphaIndex).toBeGreaterThanOrEqual(0);
+    expect(zuluIndex).toBeGreaterThanOrEqual(0);
+    expect(alphaIndex).toBeLessThan(zuluIndex);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows ready to implement tasks above task sections", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-section-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0300", "done-task", "# Task: T0300 Done Task\n");
+  writeTask(backlogRoot, "T0301", "backlog-task", "---\ndepends_on:\n  - T0300\n---\n# Task: T0301 Backlog Task\n");
+  writeTask(readyRoot, "T0302", "ready-task", "# Task: T0302 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    expect(output).toContain("Ready to Implement");
+    expect(output.indexOf("Ready to Implement")).toBeLessThan(output.indexOf("Backlog"));
+    expect(countOccurrences(output, "T0301")).toBe(2);
+    expect(countOccurrences(output, "T0302")).toBe(2);
+    expect(output).not.toContain("No tasks ready for implementation.");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows ready to implement empty state when none qualify", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-ready-empty-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyRoot = join(schubDir, "tasks", "ready");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+
+  writeTask(readyRoot, "T0401", "ready-task", "---\ndepends_on:\n  - T0402\n---\n# Task: T0401 Ready Task\n");
+  writeTask(backlogRoot, "T0402", "backlog-task", "---\ndepends_on:\n  - T0403\n---\n# Task: T0402 Backlog Task\n");
+  writeTask(backlogRoot, "T0403", "waiting-task", "---\ndepends_on:\n  - T0404\n---\n# Task: T0403 Waiting Task\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    expect(output).toContain("Ready to Implement");
+    expect(output).toContain("No tasks ready for implementation.");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view hides pending implementation when tasks complete", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-complete-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const doneRoot = join(schubDir, "tasks", "done");
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  const completedChange = "C0003_all-done";
+
+  writeProposal(changesRoot, completedChange, "Accepted");
+  writeTask(doneRoot, "T0020", "done-task", `---\nchange_id: ${completedChange}\n---\n# Task: T0020 Done Task\n`);
+  writeTask(doneRoot, "T0021", "done-task-two", `---\nchange_id: ${completedChange}\n---\n# Task: T0021 Done Task\n`);
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+
+    expect(output).not.toContain(completedChange);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view auto-marks completed accepted changes as done", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-auto-done-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const doneRoot = join(schubDir, "tasks", "done");
+  const refreshIntervalMs = 50;
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  const changeId = "C0011_auto-done";
+  const proposalPath = join(changesRoot, changeId, "proposal.md");
+
+  writeProposal(changesRoot, changeId, "Accepted");
+  writeTask(doneRoot, "T0100", "done-task", `---\nchange_id: ${changeId}\n---\n# Task: T0100 Done Task\n`);
+  writeTask(doneRoot, "T0101", "done-task-two", `---\nchange_id: ${changeId}\n---\n# Task: T0101 Done Task\n`);
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const updated = readFileSync(proposalPath, "utf8");
+    expect(updated).toContain("status: Done");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view does not auto-mark proposals without tasks", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-no-tasks-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const refreshIntervalMs = 50;
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeId = "C0012_no-tasks";
+  const proposalPath = join(changesRoot, changeId, "proposal.md");
+
+  writeProposal(changesRoot, changeId, "Accepted");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const updated = readFileSync(proposalPath, "utf8");
+    expect(updated).toContain("status: Accepted");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view refreshes when tasks change", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-refresh-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const refreshIntervalMs = 50;
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(readyRoot, { recursive: true });
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+    const output = stripAnsi(rendered.lastFrame() ?? "");
+    expect(output).toContain("No active changes or tasks found.");
+
+    writeTask(readyRoot, "T0001", "new-task", "# Task: T0001 New Task\n");
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const refreshed = stripAnsi(rendered.lastFrame() ?? "");
+    expect(refreshed).toContain("T0001");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view shows show-all tasks row in the tasks section", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-show-all-tasks-row-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0700", "backlog-task", "# Task: T0700 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<StatusView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const rowLine = findLine(output, "Show all tasks");
+
+    expect(rowLine).toContain("Show all tasks");
+    expect(output.indexOf("Tasks")).toBeLessThan(output.indexOf("Show all tasks"));
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens tasks page with enter and returns on escape", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-show-all-tasks-enter-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0710", "backlog-task", "# Task: T0710 Backlog Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    const { stdin } = rendered;
+
+    await nextTick();
+    stdin.write("\u001B[B");
+    await nextTick();
+    stdin.write("\u001B[B");
+    await nextTick();
+    stdin.write("\r");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const restored = stripAnsi(rendered.lastFrame() ?? "");
+    expect(restored).toContain("Change Proposals");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view handles tasks page actions", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-tasks-actions-"));
+  const schubDir = join(base, ".schub");
+  const backlogRoot = join(schubDir, "tasks", "backlog");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const doneRoot = join(schubDir, "tasks", "done");
+  let copied = "";
+  let didImplement = false;
+  let implemented = { id: "", repoRoot: "" };
+  const opened: string[] = [];
+
+  mkdirSync(backlogRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(backlogRoot, "T0720", "backlog-task", "---\ndepends_on:\n  - T0999\n---\n# Task: T0720 Backlog Task\n");
+  writeTask(doneRoot, "T0722", "done-task", "# Task: T0722 Done Task\n");
+  writeTask(readyRoot, "T0721", "ready-task", "---\ndepends_on:\n  - T0722\n---\n# Task: T0721 Ready Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(
+      <StatusView
+        onCopyId={(id) => {
+          copied = id;
+        }}
+        onOpen={(_, path) => {
+          opened.push(path);
+        }}
+        onImplement={(id: string, repoRoot: string) => {
+          implemented = { id, repoRoot };
+          didImplement = true;
+        }}
+      />,
+    );
+    const { stdin } = rendered;
+
+    await nextTick();
+    stdin.write("t");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const subpage = stripAnsi(rendered.lastFrame() ?? "");
+    expect(subpage).toContain("All Tasks");
+
+    stdin.write("c");
+    await nextTick();
+    expect(copied).toBe("T0720");
+
+    stdin.write("o");
+    await nextTick();
+    expect(opened[0]).toContain("tasks/backlog/T0720_backlog-task.md");
+
+    stdin.write("s");
+    await nextTick();
+    const modal = normalizeWhitespace(stripAnsi(rendered.lastFrame() ?? ""));
+    expect(modal).toContain("enter confirm");
+
+    stdin.write("\u001B");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    stdin.write("i");
+    await nextTick();
+
+    expect(didImplement).toBe(true);
+    expect(implemented.id).toBe("T0721");
+    expect(realpathSync(implemented.repoRoot)).toBe(realpathSync(base));
+
+    stdin.write("q");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const restored = stripAnsi(rendered.lastFrame() ?? "");
+    expect(restored).toContain("Change Proposals");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens proposal detail on enter from main list", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-detail-enter-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const changeId = "C1300_detail-view";
+  let opened = "";
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, changeId, "Draft", "Detail View");
+
+  try {
+    process.chdir(base);
+    const rendered = render(
+      <StatusView
+        onCopyId={noopCopy}
+        onOpenDetail={(value: string) => {
+          opened = value;
+        }}
+      />,
+    );
+
+    await nextTick();
+    await nextTick();
+
+    rendered.stdin.write("\n");
+    await nextTick();
+    await nextTick();
+
+    expect(opened).toBe(changeId);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view opens proposal detail on enter from show-all list", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-detail-show-all-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const changeId = "C1301_detail-show-all";
+  let opened = "";
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, changeId, "Draft", "Detail Show All");
+
+  try {
+    process.chdir(base);
+    const rendered = render(
+      <StatusView
+        onCopyId={noopCopy}
+        onOpenDetail={(value: string) => {
+          opened = value;
+        }}
+      />,
+    );
+
+    await nextTick();
+    await nextTick();
+
+    rendered.stdin.write("p");
+    await nextTick();
+    await nextTick();
+
+    rendered.stdin.write("\n");
+    await nextTick();
+    await nextTick();
+
+    expect(opened).toBe(changeId);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view renders all-tasks groups in task status order", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-all-tasks-groups-"));
+  const schubDir = join(base, ".schub");
+
+  const tasks = [
+    { status: "backlog", label: "Backlog", id: "T0701", slug: "zulu-backlog-task", title: "zulu backlog task" },
+    { status: "backlog", label: "Backlog", id: "T0702", slug: "alpha-backlog-task", title: "alpha backlog task" },
+    { status: "ready", label: "Ready", id: "T0703", slug: "ready-task", title: "ready task" },
+    { status: "wip", label: "WIP", id: "T0704", slug: "wip-task", title: "wip task" },
+    { status: "blocked", label: "Blocked", id: "T0705", slug: "blocked-task", title: "blocked task" },
+    { status: "done", label: "Done", id: "T0706", slug: "done-task", title: "done task" },
+    { status: "archived", label: "Archived", id: "T0707", slug: "archived-task", title: "archived task" },
+  ] as const;
+  const groupLabels = ["Backlog", "Ready", "WIP", "Blocked", "Done", "Archived"] as const;
+
+  for (const task of tasks) {
+    const root = join(schubDir, "tasks", task.status);
+    mkdirSync(root, { recursive: true });
+    const body =
+      task.status === "blocked"
+        ? `---\nblocked_reason: ${task.title}\n---\n# Task: ${task.id} ${task.title}\n`
+        : `# Task: ${task.id} ${task.title}\n`;
+    writeTask(root, task.id, task.slug, body);
+  }
+
+  try {
+    process.chdir(base);
+    const groups = buildShowAllTaskGroups(schubDir);
+    const { lastFrame } = render(<StatusShowAllTasksView selection={0} showAllTaskGroups={groups} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const lines = output.split("\n");
+
+    const labelIndexes = groupLabels.map((label) => lines.findIndex((line) => line.trim() === label));
+    for (const index of labelIndexes) {
+      expect(index).toBeGreaterThanOrEqual(0);
+    }
+    for (let i = 1; i < labelIndexes.length; i += 1) {
+      expect(labelIndexes[i]).toBeGreaterThan(labelIndexes[i - 1]);
+    }
+
+    const backlogSection = extractSection(output, "Backlog", "Ready");
+    const alphaIndex = backlogSection.indexOf("alpha backlog task");
+    const zuluIndex = backlogSection.indexOf("zulu backlog task");
+    expect(alphaIndex).toBeGreaterThanOrEqual(0);
+    expect(zuluIndex).toBeGreaterThanOrEqual(0);
+    expect(alphaIndex).toBeLessThan(zuluIndex);
+
+    for (const task of tasks) {
+      const line = findLine(output, task.id);
+      expect(line).toContain(task.title);
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test.skip("status view refreshes when proposals change", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-proposal-refresh-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const refreshIntervalMs = 50;
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeId = "C0010_refresh-proposal";
+  const displayId = changeDisplayId(changeId);
+  writeProposal(changesRoot, changeId, "Draft");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+    const output = stripAnsi(rendered.lastFrame() ?? "");
+
+    expect(output).toContain("Drafts");
+    expect(findLine(output, displayId)).toContain(displayId);
+
+    writeProposal(changesRoot, changeId, "Accepted");
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const refreshed = stripAnsi(rendered.lastFrame() ?? "");
+    expect(refreshed).toContain("No Tasks Defined");
+    expect(findLine(refreshed, displayId)).toContain(displayId);
+    expect(refreshed).not.toContain("Drafts");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});
+
+test.skip("status view clamps selection when tasks are removed", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-selection-"));
+  const schubDir = join(base, ".schub");
+  const readyRoot = join(schubDir, "tasks", "ready");
+  const refreshIntervalMs = 50;
+  const selectionMarker = "\u203A";
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeTask(readyRoot, "T0001", "alpha-task", "# Task: T0001 Alpha Task\n");
+  writeTask(readyRoot, "T0002", "beta-task", "# Task: T0002 Beta Task\n");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+    const { stdin } = rendered;
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const moved = stripAnsi(rendered.lastFrame() ?? "");
+    expect(hasSelectionMarker(moved, "T0002", selectionMarker)).toBe(true);
+
+    unlinkSync(join(readyRoot, "T0002_beta-task.md"));
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const refreshed = stripAnsi(rendered.lastFrame() ?? "");
+    expect(hasSelectionMarker(refreshed, "T0001", selectionMarker)).toBe(true);
+    expect(refreshed).not.toContain("T0002");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});
+
+test.skip("status view shows show-all proposals subpage and actions", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-show-all-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const archiveRoot = join(schubDir, "archive", "changes");
+  const nextTick = () => new Promise((resolve) => setTimeout(resolve, 0));
+  let copied = "";
+  const opened: string[] = [];
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(archiveRoot, { recursive: true });
+
+  const draftAlpha = "C0001_alpha-proposal";
+  const draftBravo = "C0002_bravo-proposal";
+  const pendingReview = "C0003_pending-review";
+  const accepted = "C0004_accepted";
+  const implementing = "C0005_implementing";
+  const done = "C0006_done";
+  const archived = "C0007_archived";
+
+  writeProposal(changesRoot, draftAlpha, "Draft", "Alpha Proposal");
+  writeProposal(changesRoot, draftBravo, "Draft", "Bravo Proposal");
+  writeProposal(changesRoot, pendingReview, "Pending Review", "Pending Proposal");
+  writeProposal(changesRoot, accepted, "Accepted", "Accepted Proposal");
+  writeProposal(changesRoot, implementing, "Implementing", "Implementing Proposal");
+  writeProposal(changesRoot, done, "Done", "Done Proposal");
+  writeProposal(archiveRoot, archived, "Archived", "Archived Proposal");
+
+  try {
+    process.chdir(base);
+    const rendered = render(
+      <StatusView
+        onCopyId={(id) => {
+          copied = id;
+        }}
+        onOpen={(_, path) => {
+          opened.push(path);
+        }}
+      />,
+    );
+    const { stdin } = rendered;
+
+    const initial = stripAnsi(rendered.lastFrame() ?? "");
+    expect(initial).toContain("Show all proposals");
+
+    stdin.write("p");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const output = stripAnsi(rendered.lastFrame() ?? "");
+    const groupLabels = ["Draft", "Pending Review", "Accepted", "Implementing", "Done", "Archived"];
+    const groupIndexes = groupLabels.map((label) => output.indexOf(label));
+    for (const index of groupIndexes) {
+      expect(index).toBeGreaterThanOrEqual(0);
+    }
+    for (let i = 1; i < groupIndexes.length; i += 1) {
+      expect(groupIndexes[i]).toBeGreaterThan(groupIndexes[i - 1]);
+    }
+
+    const alphaIndex = output.indexOf(changeDisplayId(draftAlpha));
+    const bravoIndex = output.indexOf(changeDisplayId(draftBravo));
+    expect(alphaIndex).toBeGreaterThanOrEqual(0);
+    expect(bravoIndex).toBeGreaterThan(alphaIndex);
+    expect(output).toContain(changeDisplayId(archived));
+
+    stdin.write("c");
+    await nextTick();
+    expect(copied).toBe(draftAlpha);
+
+    stdin.write("o");
+    await nextTick();
+    expect(opened).toHaveLength(1);
+    expect(opened[0]).toContain(`${draftAlpha}/proposal.md`);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test.skip("status view opens show-all proposals with enter and returns on escape", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-show-all-enter-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+
+  const changeId = "C0008_enter-show-all";
+  writeProposal(changesRoot, changeId, "Draft", "Enter Show All");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} />);
+    const { stdin } = rendered;
+
+    const initial = stripAnsi(rendered.lastFrame() ?? "");
+    expect(initial).toContain("Show all proposals");
+
+    await nextTick();
+    stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    stdin.write("\n");
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    const subpage = stripAnsi(rendered.lastFrame() ?? "");
+    expect(subpage).toContain("All Proposals · esc to return");
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    stdin.write("q");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    const restored = stripAnsi(rendered.lastFrame() ?? "");
+    expect(restored).toContain("Change Proposals");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});