schub 0.1.2 → 0.1.3

package/src/components/PlanView.test.tsx

@@ -33,7 +33,7 @@ test("plan shows backlog tasks with satisfied dependencies as ready", () => {
   const base = mkdtempSync(join(tmpdir(), "schub-plan-view-"));
   const tasksDir = join(base, ".schub", "tasks", "backlog");
   mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(tasksDir, "T001_ready-task.md"), "# Task: T001 Ready Task\n", "utf8");
+  writeFileSync(join(tasksDir, "T0001_ready-task.md"), "# Task: T0001 Ready Task\n", "utf8");
 
   try {
     process.chdir(base);
@@ -41,7 +41,7 @@ test("plan shows backlog tasks with satisfied dependencies as ready", () => {
     const output = stripAnsi(lastFrame() ?? "");
     const readySection = extractSection(output, "Ready to Implement", "Dependency Plan");
 
-    expect(readySection).toContain("T001");
+    expect(readySection).toContain("T0001");
     expect(readySection).not.toContain("No tasks ready for implementation.");
   } finally {
     process.chdir(originalCwd);
@@ -53,7 +53,7 @@ test("plan view omits per-item shortcuts for ready tasks", () => {
   const base = mkdtempSync(join(tmpdir(), "schub-plan-actions-"));
   const tasksDir = join(base, ".schub", "tasks", "backlog");
   mkdirSync(tasksDir, { recursive: true });
-  writeFileSync(join(tasksDir, "T010_quick-action.md"), "# Task: T010 Quick Action\n", "utf8");
+  writeFileSync(join(tasksDir, "T0010_quick-action.md"), "# Task: T0010 Quick Action\n", "utf8");
 
   try {
     process.chdir(base);
@@ -61,7 +61,7 @@ test("plan view omits per-item shortcuts for ready tasks", () => {
     const output = stripAnsi(lastFrame() ?? "");
     const readySection = extractSection(output, "Ready to Implement", "Dependency Plan");
 
-    expect(readySection).toContain("T010");
+    expect(readySection).toContain("T0010");
     expect(readySection).not.toContain("[o open file]");
     expect(readySection).not.toContain("[c copy]");
   } finally {
@@ -83,29 +83,29 @@ test("plan view refreshes ready list and dependency graph when tasks change", as
   try {
     process.chdir(base);
     writeFileSync(
-      join(tasksDir, "T002_waiting-task.md"),
-      "# Task: T002 Waiting Task\n\n**Depends on**: T003\n",
+      join(tasksDir, "T0002_waiting-task.md"),
+      "# Task: T0002 Waiting Task\n\n**Depends on**: T0003\n",
       "utf8",
     );
-    writeFileSync(join(tasksDir, "T003_dependency.md"), "# Task: T003 Dependency\n", "utf8");
+    writeFileSync(join(tasksDir, "T0003_dependency.md"), "# Task: T0003 Dependency\n", "utf8");
     const rendered = render(<PlanView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
     unmount = rendered.unmount;
     const initial = stripAnsi(rendered.lastFrame() ?? "");
     const initialReady = extractSection(initial, "Ready to Implement", "Dependency Plan");
-    expect(initialReady).not.toContain("T002");
+    expect(initialReady).not.toContain("T0002");
     const initialGraph = extractSection(initial, "Dependency Plan");
-    expect(initialGraph).toContain("T002");
-    expect(initialGraph).toContain("T003");
+    expect(initialGraph).toContain("T0002");
+    expect(initialGraph).toContain("T0003");
 
-    renameSync(join(tasksDir, "T003_dependency.md"), join(doneDir, "T003_dependency.md"));
+    renameSync(join(tasksDir, "T0003_dependency.md"), join(doneDir, "T0003_dependency.md"));
     await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
 
     const refreshed = stripAnsi(rendered.lastFrame() ?? "");
     const refreshedReady = extractSection(refreshed, "Ready to Implement", "Dependency Plan");
-    expect(refreshedReady).toContain("T002");
+    expect(refreshedReady).toContain("T0002");
     const refreshedGraph = extractSection(refreshed, "Dependency Plan");
-    expect(refreshedGraph).toContain("T002");
-    expect(refreshedGraph).not.toContain("T003");
+    expect(refreshedGraph).toContain("T0002");
+    expect(refreshedGraph).not.toContain("T0003");
   } finally {
     unmount?.();
     process.chdir(originalCwd);

package/src/components/StatusView.test.tsx

@@ -37,20 +37,20 @@ test("status view shows checklist indicator only for wip tasks", () => {
   mkdirSync(wipRoot, { recursive: true });
   mkdirSync(readyRoot, { recursive: true });
 
-  writeTask(wipRoot, "T100", "wip-checklist", "# Task: T100 Wip Checklist\n\n## Steps\n- [ ] First\n- [x] Second\n");
-  writeTask(wipRoot, "T101", "wip-complete", "# Task: T101 Wip Complete\n\n## Steps\n- [x] First\n- [x] Second\n");
-  writeTask(wipRoot, "T102", "wip-empty", "# Task: T102 Wip Empty\n\n## Steps\n- Do the thing\n");
-  writeTask(readyRoot, "T200", "ready-checklist", "# Task: T200 Ready Checklist\n\n## Steps\n- [ ] First\n");
+  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, "T100");
-    const wipCompleteLine = findLine(output, "T101");
-    const wipEmptyLine = findLine(output, "T102");
-    const readyLine = findLine(output, "T200");
+    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)");
@@ -74,11 +74,11 @@ test("status view omits per-item shortcuts for tasks and proposals", () => {
   mkdirSync(changesRoot, { recursive: true });
   mkdirSync(readyRoot, { recursive: true });
 
-  const changeId = "C003_demo-change";
+  const changeId = "C0003_demo-change";
   const displayId = changeDisplayId(changeId);
 
   writeProposal(changesRoot, changeId, "Draft");
-  writeTask(readyRoot, "T003", "ready-task", "# Task: T003 Ready Task\n");
+  writeTask(readyRoot, "T0003", "ready-task", "# Task: T0003 Ready Task\n");
 
   try {
     process.chdir(base);
@@ -87,8 +87,8 @@ test("status view omits per-item shortcuts for tasks and proposals", () => {
 
     expect(findLine(output, displayId)).not.toContain("[o open file]");
     expect(findLine(output, displayId)).not.toContain("[c copy]");
-    expect(findLine(output, "T003")).not.toContain("[o open file]");
-    expect(findLine(output, "T003")).not.toContain("[c copy]");
+    expect(findLine(output, "T0003")).not.toContain("[o open file]");
+    expect(findLine(output, "T0003")).not.toContain("[c copy]");
   } finally {
     process.chdir(originalCwd);
   }
@@ -102,7 +102,7 @@ test("status view shows proposal titles", () => {
 
   mkdirSync(changesRoot, { recursive: true });
 
-  const changeId = "C004_pretty-proposals";
+  const changeId = "C0004_pretty-proposals";
   const changeTitle = "Pretty Print Change Proposals";
   const displayId = changeDisplayId(changeId);
 
@@ -122,6 +122,33 @@ test("status view shows proposal titles", () => {
   }
 });
 
+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-"));
@@ -133,14 +160,39 @@ test("status view copies the selected id on c", async () => {
   };
 
   mkdirSync(readyRoot, { recursive: true });
-  writeTask(readyRoot, "T010", "copy-task", "# Task: T010 Copy Task\n");
+  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("T010");
+    expect(copied).toBe("T0010");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("status view triggers review on r for pending review proposals", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-status-review-"));
+  const schubDir = join(base, ".schub");
+  const changesRoot = join(schubDir, "changes");
+  const changeId = "C020_pending-review";
+  let reviewed = "";
+  const recordReview = (id: string) => {
+    reviewed = id;
+  };
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, changeId, "Pending Review");
+
+  try {
+    process.chdir(base);
+    const rendered = render(<StatusView onCopyId={noopCopy} onReview={recordReview} />);
+    rendered.stdin.write("r");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(reviewed).toBe(changeId);
   } finally {
     process.chdir(originalCwd);
   }
@@ -158,17 +210,17 @@ test("status view shows pending implementation counts and no tasks defined secti
   mkdirSync(doneRoot, { recursive: true });
   mkdirSync(changesRoot, { recursive: true });
 
-  const changeWithTasks = "C001_with-tasks";
-  const changeNoTasks = "C002_no-tasks";
+  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, "T010", "first-task", `# Task: T010 First Task\n\n**Change ID**: ${changeWithTasks}\n`);
-  writeTask(backlogRoot, "T011", "second-task", `# Task: T011 Second Task\n\n**Change ID**: ${changeWithTasks}\n`);
-  writeTask(doneRoot, "T012", "done-task", `# Task: T012 Done Task\n\n**Change ID**: ${changeWithTasks}\n`);
+  writeTask(backlogRoot, "T0010", "first-task", `# Task: T0010 First Task\n\n**Change ID**: ${changeWithTasks}\n`);
+  writeTask(backlogRoot, "T0011", "second-task", `# Task: T0011 Second Task\n\n**Change ID**: ${changeWithTasks}\n`);
+  writeTask(doneRoot, "T0012", "done-task", `# Task: T0012 Done Task\n\n**Change ID**: ${changeWithTasks}\n`);
 
   try {
     process.chdir(base);
@@ -197,11 +249,11 @@ test("status view hides pending implementation when tasks complete", () => {
   mkdirSync(changesRoot, { recursive: true });
   mkdirSync(doneRoot, { recursive: true });
 
-  const completedChange = "C003_all-done";
+  const completedChange = "C0003_all-done";
 
   writeProposal(changesRoot, completedChange, "Accepted");
-  writeTask(doneRoot, "T020", "done-task", `# Task: T020 Done Task\n\n**Change ID**: ${completedChange}\n`);
-  writeTask(doneRoot, "T021", "done-task-two", `# Task: T021 Done Task\n\n**Change ID**: ${completedChange}\n`);
+  writeTask(doneRoot, "T0020", "done-task", `# Task: T0020 Done Task\n\n**Change ID**: ${completedChange}\n`);
+  writeTask(doneRoot, "T0021", "done-task-two", `# Task: T0021 Done Task\n\n**Change ID**: ${completedChange}\n`);
 
   try {
     process.chdir(base);
@@ -226,12 +278,12 @@ test("status view auto-marks completed accepted changes as done", async () => {
   mkdirSync(changesRoot, { recursive: true });
   mkdirSync(doneRoot, { recursive: true });
 
-  const changeId = "C011_auto-done";
+  const changeId = "C0011_auto-done";
   const proposalPath = join(changesRoot, changeId, "proposal.md");
 
   writeProposal(changesRoot, changeId, "Accepted");
-  writeTask(doneRoot, "T100", "done-task", `# Task: T100 Done Task\n\n**Change ID**: ${changeId}\n`);
-  writeTask(doneRoot, "T101", "done-task-two", `# Task: T101 Done Task\n\n**Change ID**: ${changeId}\n`);
+  writeTask(doneRoot, "T0100", "done-task", `# Task: T0100 Done Task\n\n**Change ID**: ${changeId}\n`);
+  writeTask(doneRoot, "T0101", "done-task-two", `# Task: T0101 Done Task\n\n**Change ID**: ${changeId}\n`);
 
   try {
     process.chdir(base);
@@ -258,7 +310,7 @@ test("status view does not auto-mark proposals without tasks", async () => {
 
   mkdirSync(changesRoot, { recursive: true });
 
-  const changeId = "C012_no-tasks";
+  const changeId = "C0012_no-tasks";
   const proposalPath = join(changesRoot, changeId, "proposal.md");
 
   writeProposal(changesRoot, changeId, "Accepted");
@@ -295,11 +347,11 @@ test("status view refreshes when tasks change", async () => {
     const output = stripAnsi(rendered.lastFrame() ?? "");
     expect(output).toContain("No active changes or tasks found.");
 
-    writeTask(readyRoot, "T001", "new-task", "# Task: T001 New Task\n");
+    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("T001");
+    expect(refreshed).toContain("T0001");
   } finally {
     unmount?.();
     process.chdir(originalCwd);
@@ -316,7 +368,7 @@ test("status view refreshes when proposals change", async () => {
 
   mkdirSync(changesRoot, { recursive: true });
 
-  const changeId = "C010_refresh-proposal";
+  const changeId = "C0010_refresh-proposal";
   const displayId = changeDisplayId(changeId);
   writeProposal(changesRoot, changeId, "Draft");
 
@@ -352,8 +404,8 @@ test("status view clamps selection when tasks are removed", async () => {
   let unmount: (() => void) | undefined;
 
   mkdirSync(readyRoot, { recursive: true });
-  writeTask(readyRoot, "T001", "alpha-task", "# Task: T001 Alpha Task\n");
-  writeTask(readyRoot, "T002", "beta-task", "# Task: T002 Beta Task\n");
+  writeTask(readyRoot, "T0001", "alpha-task", "# Task: T0001 Alpha Task\n");
+  writeTask(readyRoot, "T0002", "beta-task", "# Task: T0002 Beta Task\n");
 
   try {
     process.chdir(base);
@@ -365,14 +417,14 @@ test("status view clamps selection when tasks are removed", async () => {
     await new Promise((resolve) => setTimeout(resolve, 0));
 
     const moved = stripAnsi(rendered.lastFrame() ?? "");
-    expect(findLine(moved, "T002")).toContain(selectionMarker);
+    expect(findLine(moved, "T0002")).toContain(selectionMarker);
 
-    unlinkSync(join(readyRoot, "T002_beta-task.md"));
+    unlinkSync(join(readyRoot, "T0002_beta-task.md"));
     await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
 
     const refreshed = stripAnsi(rendered.lastFrame() ?? "");
-    expect(findLine(refreshed, "T001")).toContain(selectionMarker);
-    expect(refreshed).not.toContain("T002");
+    expect(findLine(refreshed, "T0001")).toContain(selectionMarker);
+    expect(refreshed).not.toContain("T0002");
   } finally {
     unmount?.();
     process.chdir(originalCwd);

package/src/components/StatusView.tsx

@@ -4,6 +4,7 @@ import React from "react";
 import { type ChangeInfo, listChanges, updateChangeStatus } from "../changes";
 import { findSchubRoot, loadTaskDependencies, type TaskInfo, trimTaskTitle } from "../features/tasks";
 import { openInVsCode } from "../ide";
+import { launchOpencodeReview } from "../opencode";
 
 type StatusSortable = {
   id: string;
@@ -11,9 +12,16 @@ type StatusSortable = {
   status: string;
 };
 
+type Shortcut = {
+  keyLabel: string;
+  label: string;
+};
+
 type StatusViewProps = {
   refreshIntervalMs?: number;
   onCopyId: (id: string) => void;
+  onReview?: (changeId: string) => void;
+  onShortcutsChange?: (shortcuts: Shortcut[]) => void;
 };
 
 const DEFAULT_REFRESH_INTERVAL_MS = 1000;
@@ -26,6 +34,7 @@ type ChangeTaskCount = {
 };
 
 const AUTO_MARK_STATUSES = new Set(["accepted", "wip"]);
+const REVIEW_SHORTCUT: Shortcut = { keyLabel: "r", label: "review" };
 
 const compareText = (left: string, right: string): number =>
   left.localeCompare(right, undefined, { sensitivity: "base" });
@@ -50,10 +59,27 @@ const isTaskItem = (item: ChangeInfo | TaskInfo): item is TaskInfo => {
 };
 
 const formatChangeId = (value: string) => {
-  const match = value.match(/^([Cc]\d{3})_/);
+  const match = value.match(/^([Cc]\d{4})_/);
   return match ? match[1].toUpperCase() : value;
 };
 
+const formatChangeTitle = (changeId: string, title: string) => {
+  const trimmedTitle = title.trim();
+  if (trimmedTitle !== changeId) {
+    return trimmedTitle;
+  }
+
+  const match = changeId.match(/^([Cc]\d{4})_(.+)$/);
+  if (!match) {
+    return trimmedTitle;
+  }
+
+  return match[2]
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+};
+
 const canAutoMarkChange = (status: string) => AUTO_MARK_STATUSES.has(status.trim().toLowerCase());
 
 const autoMarkChangesDone = (schubDir: string) => {
@@ -185,7 +211,12 @@ const buildStatusData = (schubDir: string | null) => {
   };
 };
 
-export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, onCopyId }: StatusViewProps) {
+export default function StatusView({
+  refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS,
+  onCopyId,
+  onReview = launchOpencodeReview,
+  onShortcutsChange,
+}: StatusViewProps) {
   const schubDir = findSchubRoot();
   const [, setRefreshTick] = React.useState(0);
   const {
@@ -214,6 +245,24 @@ export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVA
 
   const [selection, setSelection] = React.useState(0);
   const totalItems = allItems.length;
+  const pendingReviewIds = new Set(pendingReview.map((change) => change.id));
+  const selectedItem = totalItems > 0 ? allItems[selection] : null;
+  const selectedReviewId =
+    selectedItem && !isTaskItem(selectedItem) && pendingReviewIds.has(selectedItem.id) ? selectedItem.id : null;
+  const lastReviewIdRef = React.useRef<string | null>(null);
+
+  React.useEffect(() => {
+    if (!onShortcutsChange) {
+      return;
+    }
+
+    if (lastReviewIdRef.current === selectedReviewId) {
+      return;
+    }
+
+    lastReviewIdRef.current = selectedReviewId;
+    onShortcutsChange(selectedReviewId ? [REVIEW_SHORTCUT] : []);
+  }, [onShortcutsChange, selectedReviewId]);
 
   React.useEffect(() => {
     if (!schubDir) {
@@ -260,6 +309,10 @@ export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVA
       const selectedItem = allItems[selection];
       onCopyId(selectedItem.id);
     }
+
+    if (input === "r" && selectedReviewId) {
+      onReview(selectedReviewId);
+    }
   });
 
   if (!schubDir) {
@@ -287,7 +340,7 @@ export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVA
       task && task.status === "wip" && typeof task.checklistTotal === "number"
         ? ` (${task.checklistRemaining ?? 0}/${task.checklistTotal})`
         : "";
-    const changeTitle = item.title;
+    const changeTitle = task ? "" : formatChangeTitle(item.id, item.title);
     const changeDetail = detail ? ` ${detail}` : "";
     const displayTitle = task ? `${title}${checklistIndicator}` : `${changeTitle}${changeDetail}`.trim();
     const displayId = task ? item.id : formatChangeId(item.id);

package/src/features/tasks/create.ts

@@ -29,13 +29,13 @@ export const createTask = (
   const titles = options.titles.map((t) => t.trim()).filter(Boolean);
 
   // Validate change ID format (simple check)
-  if (!/^(?:[Cc]\d{3}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/.test(changeId)) {
-    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`);
+  if (!/^(?:[Cc]\d{4}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/.test(changeId)) {
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C0001_add-user-auth).`);
   }
 
   // Normalize change ID (ensure C prefix if it matches pattern)
   let normalizedChangeId = changeId;
-  const match = changeId.match(/^([Cc])(\d{3})_(.+)$/);
+  const match = changeId.match(/^([Cc])(\d{4})_(.+)$/);
   if (match) {
     normalizedChangeId = `C${match[2]}_${match[3]}`;
   }
@@ -86,7 +86,7 @@ export const createTask = (
         if (entry.isDirectory()) {
           scan(join(dir, entry.name));
         } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          const m = entry.name.match(/(?:^|-)T(\d{3})(?:_[^.]+)?\.md$/);
+          const m = entry.name.match(/(?:^|-)T(\d{4})(?:_[^.]+)?\.md$/);
           if (m) existingNumbers.add(Number.parseInt(m[1], 10));
         }
       }
@@ -102,7 +102,7 @@ export const createTask = (
   const createdPaths: string[] = [];
 
   for (const title of titles) {
-    const taskId = `T${nextNumber.toString().padStart(3, "0")}`;
+    const taskId = `T${nextNumber.toString().padStart(4, "0")}`;
     let slug = title
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, "-")

package/src/features/tasks/filesystem.test.ts

@@ -1,8 +1,8 @@
 import { expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { listTasks, loadTaskDependencies } from "./filesystem";
+import { archiveTasksForChange, listTasks, loadTaskDependencies } from "./filesystem";
 
 const setupChecklistRepo = () => {
   const base = mkdtempSync(join(tmpdir(), "schub-checklist-"));
@@ -12,24 +12,24 @@ const setupChecklistRepo = () => {
 
   const tasks = [
     {
-      id: "T001",
+      id: "T0001",
       slug: "unchecked-only",
-      body: `# Task: T001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
+      body: `# Task: T0001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
     },
     {
-      id: "T002",
+      id: "T0002",
       slug: "checked-only",
-      body: `# Task: T002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
+      body: `# Task: T0002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
     },
     {
-      id: "T003",
+      id: "T0003",
       slug: "mixed-checklist",
-      body: `# Task: T003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
+      body: `# Task: T0003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
     },
     {
-      id: "T004",
+      id: "T0004",
       slug: "missing-checklist",
-      body: `# Task: T004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
+      body: `# Task: T0004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
     },
   ];
 
@@ -41,6 +41,36 @@ const setupChecklistRepo = () => {
   return schubDir;
 };
 
+const setupArchiveRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-archive-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks");
+  const statuses = ["backlog", "wip", "done"];
+
+  for (const status of statuses) {
+    mkdirSync(join(tasksRoot, status), { recursive: true });
+  }
+
+  const changeId = "C0001_archive-change";
+  writeFileSync(
+    join(tasksRoot, "backlog", "T0010_backlog-task.md"),
+    `# Task: T0010 Backlog Task\n\n**Change ID**: \`${changeId}\`\n`,
+    "utf8",
+  );
+  writeFileSync(
+    join(tasksRoot, "wip", "T0011_wip-task.md"),
+    `# Task: T0011 Wip Task\n\n**Change ID**: \`${changeId}\`\n`,
+    "utf8",
+  );
+  writeFileSync(
+    join(tasksRoot, "done", "T0012_other-task.md"),
+    "# Task: T0012 Other Task\n\n**Change ID**: `C0002_other-change`\n",
+    "utf8",
+  );
+
+  return { schubDir, tasksRoot, changeId };
+};
+
 const getTaskById = <T extends { id: string }>(tasks: T[], id: string) => {
   return tasks.find((task) => task.id === id);
 };
@@ -49,10 +79,10 @@ test("listTasks includes Steps-only checklist counts", () => {
   const schubDir = setupChecklistRepo();
   const tasks = listTasks(schubDir);
 
-  const unchecked = getTaskById(tasks, "T001");
-  const checked = getTaskById(tasks, "T002");
-  const mixed = getTaskById(tasks, "T003");
-  const missing = getTaskById(tasks, "T004");
+  const unchecked = getTaskById(tasks, "T0001");
+  const checked = getTaskById(tasks, "T0002");
+  const mixed = getTaskById(tasks, "T0003");
+  const missing = getTaskById(tasks, "T0004");
 
   expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
   expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
@@ -65,10 +95,10 @@ test("loadTaskDependencies includes Steps-only checklist counts", () => {
   const schubDir = setupChecklistRepo();
   const tasks = loadTaskDependencies(schubDir);
 
-  const unchecked = getTaskById(tasks, "T001");
-  const checked = getTaskById(tasks, "T002");
-  const mixed = getTaskById(tasks, "T003");
-  const missing = getTaskById(tasks, "T004");
+  const unchecked = getTaskById(tasks, "T0001");
+  const checked = getTaskById(tasks, "T0002");
+  const mixed = getTaskById(tasks, "T0003");
+  const missing = getTaskById(tasks, "T0004");
 
   expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
   expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
@@ -76,3 +106,23 @@ test("loadTaskDependencies includes Steps-only checklist counts", () => {
   expect(missing?.checklistTotal).toBeUndefined();
   expect(missing?.checklistRemaining).toBeUndefined();
 });
+
+test("archiveTasksForChange moves matching tasks to archived", () => {
+  const { schubDir, tasksRoot, changeId } = setupArchiveRepo();
+  const archived = archiveTasksForChange(schubDir, changeId);
+
+  const archiveRoot = join(tasksRoot, "archived");
+  const backlogTask = join(archiveRoot, "T0010_backlog-task.md");
+  const wipTask = join(archiveRoot, "T0011_wip-task.md");
+
+  expect(existsSync(archiveRoot)).toBe(true);
+  expect(existsSync(backlogTask)).toBe(true);
+  expect(existsSync(wipTask)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0010_backlog-task.md"))).toBe(false);
+  expect(existsSync(join(tasksRoot, "wip", "T0011_wip-task.md"))).toBe(false);
+  expect(existsSync(join(tasksRoot, "done", "T0012_other-task.md"))).toBe(true);
+
+  expect(archived.map((task) => task.id)).toEqual(["T0010", "T0011"]);
+  expect(archived.every((task) => task.status === "archived")).toBe(true);
+  expect(archived[0]?.path).toContain(".schub/tasks/archived/");
+});

package/src/features/tasks/filesystem.ts

@@ -1,5 +1,5 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { TASK_STATUSES, type TaskDependency, type TaskInfo, type TaskStatus } from "./constants";
 import { compareTaskIds, compareTasks } from "./sorting";
 
@@ -40,6 +40,9 @@ const parseTaskFilename = (fileName: string): { id: string; title: string } | nu
   }
 
   const id = baseName.slice(0, underscoreIndex);
+  if (!/^T\d{4}$/.test(id)) {
+    return null;
+  }
   const titleSlug = baseName.slice(underscoreIndex + 1);
   return { id, title: titleSlug.replace(/-/g, " ") };
 };
@@ -112,7 +115,7 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
   if (dependsMatch) {
     const raw = dependsMatch[1].trim();
     if (!/^none$/i.test(raw)) {
-      const matches = raw.match(/\bT\d+\b/g);
+      const matches = raw.match(/\bT\d{4}\b/g);
       if (matches) {
         dependsOn = Array.from(new Set(matches));
       }
@@ -230,3 +233,29 @@ export const loadTaskDependencies = (
 
   return tasks.sort(compareTasks);
 };
+
+const ACTIVE_TASK_STATUSES = TASK_STATUSES.filter((status) => status !== "archived");
+
+export const archiveTasksForChange = (schubDir: string, changeId: string) => {
+  const normalizedChangeId = changeId.trim();
+  const tasksRoot = join(schubDir, "tasks");
+  const archiveRoot = join(tasksRoot, "archived");
+  mkdirSync(archiveRoot, { recursive: true });
+
+  const repoRoot = dirname(schubDir);
+  const tasks = loadTaskDependencies(schubDir, ACTIVE_TASK_STATUSES).filter(
+    (task) => task.changeId === normalizedChangeId,
+  );
+
+  return tasks.map((task) => {
+    const currentPath = join(repoRoot, task.path);
+    const archivePath = join(archiveRoot, basename(task.path));
+    renameSync(currentPath, archivePath);
+
+    return {
+      ...task,
+      status: "archived",
+      path: relative(repoRoot, archivePath),
+    };
+  });
+};