schub 0.1.2 → 0.1.3

package/src/commands/changes.ts

@@ -1,4 +1,5 @@
-import { createChange, resolveChangeRoot, updateChangeStatus } from "../changes";
+import { archiveChange, createChange, listChanges, resolveChangeRoot, updateChangeStatus } from "../changes";
+import { archiveTasksForChange } from "../tasks";
 
 type ChangeCreateOptions = {
   changeId?: string;
@@ -12,6 +13,11 @@ type ChangeStatusOptions = {
   status: string;
 };
 
+type ChangeArchiveOptions = {
+  changeId: string;
+  skipTasks: boolean;
+};
+
 const parseChangeCreateOptions = (args: string[]) => {
   let changeId: string | undefined;
   let title: string | undefined;
@@ -148,6 +154,82 @@ const parseChangeStatusOptions = (args: string[]) => {
   return options;
 };
 
+const parseChangeArchiveOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let skipTasks = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--skip-tasks") {
+      skipTasks = true;
+      continue;
+    }
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!changeId) {
+    throw new Error("Provide --change-id.");
+  }
+
+  const options: ChangeArchiveOptions = { changeId, skipTasks };
+  return options;
+};
+
+const parseChangeListOptions = (args: string[]) => {
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (const arg of args) {
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+};
+
 export const runChangesCreate = (args: string[], startDir: string) => {
   const options = parseChangeCreateOptions(args);
   const schubDir = resolveChangeRoot(startDir);
@@ -161,3 +243,22 @@ export const runChangesStatus = (args: string[], startDir: string) => {
   const updated = updateChangeStatus(schubDir, options.changeId, options.status);
   process.stdout.write(`[OK] Updated status for ${updated.changeId}: ${updated.previousStatus} -> ${updated.status}\n`);
 };
+
+export const runChangesArchive = (args: string[], startDir: string) => {
+  const options = parseChangeArchiveOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const archived = archiveChange(schubDir, options.changeId);
+  const archivedTasks = options.skipTasks ? [] : archiveTasksForChange(schubDir, archived.changeId);
+  const taskLabel = options.skipTasks
+    ? "tasks kept"
+    : `${archivedTasks.length} task${archivedTasks.length === 1 ? "" : "s"} archived`;
+  process.stdout.write(`[OK] Archived change ${archived.changeId} (${taskLabel})\n`);
+};
+
+export const runChangesList = (args: string[], startDir: string) => {
+  parseChangeListOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const changes = listChanges(schubDir);
+  const lines = changes.map((change) => `${change.id} ${change.title} (${change.status})`);
+  process.stdout.write(`${lines.join("\n")}\n`);
+};

package/src/commands/cookbook.test.ts

@@ -49,7 +49,7 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
 
 test("cookbook create scaffolds cookbook file", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C004_new-cookbook";
+  const changeId = "C0004_new-cookbook";
   const changeTitle = "New Cookbook";
   seedChange(schubRoot, changeId, changeTitle);
 

package/src/commands/init.test.ts

@@ -3,7 +3,13 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { installCodexSkills, resolveCodexSkillsRoot, selectProviders } from "./init";
+import {
+  installCodexSkills,
+  installOpencodeSkills,
+  resolveCodexSkillsRoot,
+  resolveOpencodeSkillsRoot,
+  selectProviders,
+} from "./init";
 
 const createRepoFixture = () => {
   const base = mkdtempSync(join(tmpdir(), "schub-init-codex-"));
@@ -15,7 +21,9 @@ const createRepoFixture = () => {
 
 test("selectProviders handles numeric and named inputs", () => {
   expect(selectProviders("1")).toEqual(["codex"]);
-  expect(selectProviders("codex, 1")).toEqual(["codex"]);
+  expect(selectProviders("2")).toEqual(["opencode"]);
+  expect(selectProviders("codex, opencode")).toEqual(["codex", "opencode"]);
+  expect(selectProviders("Opencode, 1")).toEqual(["opencode", "codex"]);
 });
 
 test("resolveCodexSkillsRoot prefers worktree .codex when present", () => {
@@ -63,6 +71,51 @@ test("resolveCodexSkillsRoot uses cwd when git is unavailable", () => {
   }
 });
 
+test("resolveOpencodeSkillsRoot prefers worktree .opencode when present", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  mkdirSync(join(repoRoot, ".opencode"), { recursive: true });
+
+  const destination = resolveOpencodeSkillsRoot(startDir);
+  const expectedRoot = realpathSync(repoRoot);
+
+  expect(destination).toBe(join(expectedRoot, ".opencode", "skills"));
+});
+
+test("resolveOpencodeSkillsRoot falls back to home when worktree .opencode is missing", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  const originalHome = process.env.HOME;
+  const homeDir = mkdtempSync(join(tmpdir(), "schub-home-"));
+  process.env.HOME = homeDir;
+
+  try {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    expect(destination).toBe(join(homeDir, ".opencode", "skills"));
+  } finally {
+    process.env.HOME = originalHome;
+  }
+});
+
+test("resolveOpencodeSkillsRoot uses cwd when git is unavailable", () => {
+  const { startDir } = createRepoFixture();
+  const originalPath = process.env.PATH;
+  process.env.PATH = "";
+
+  try {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    expect(destination).toBe(join(startDir, ".opencode", "skills"));
+  } finally {
+    process.env.PATH = originalPath;
+  }
+});
+
 test("installCodexSkills skips existing skill directories", () => {
   const base = mkdtempSync(join(tmpdir(), "schub-init-install-"));
   const destination = join(base, "skills");
@@ -76,3 +129,17 @@ test("installCodexSkills skips existing skill directories", () => {
   expect(installed.length).toBeGreaterThan(0);
   expect(existsSync(join(destination, "create-tasks", "SKILL.md"))).toBe(true);
 });
+
+test("installOpencodeSkills skips existing skill directories", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-init-opencode-install-"));
+  const destination = join(base, "skills");
+  const existingSkill = join(destination, "review-proposal");
+  mkdirSync(existingSkill, { recursive: true });
+  writeFileSync(join(existingSkill, "SKILL.md"), "existing", "utf8");
+
+  const { installed, skipped } = installOpencodeSkills(destination);
+
+  expect(skipped).toContain("review-proposal");
+  expect(installed.length).toBeGreaterThan(0);
+  expect(existsSync(join(destination, "create-tasks", "SKILL.md"))).toBe(true);
+});

package/src/commands/init.ts

@@ -5,14 +5,17 @@ import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { initSchubRoot, resolveGitRoot } from "../init";
 
-type ProviderId = "codex";
+type ProviderId = "codex" | "opencode";
 
 type ProviderOption = {
   id: ProviderId;
   label: string;
 };
 
-const PROVIDERS: ProviderOption[] = [{ id: "codex", label: "Codex" }];
+const PROVIDERS: ProviderOption[] = [
+  { id: "codex", label: "Codex" },
+  { id: "opencode", label: "Opencode" },
+];
 const BUNDLED_SKILLS_ROOT = fileURLToPath(new URL("../../skills", import.meta.url));
 
 const isDirectory = (path: string) => {
@@ -82,7 +85,24 @@ export const resolveCodexSkillsRoot = (startDir: string) => {
   return join(home, ".codex", "skills");
 };
 
-export const installCodexSkills = (destination: string) => {
+export const resolveOpencodeSkillsRoot = (startDir: string) => {
+  const resolvedStart = resolve(startDir);
+  const gitRoot = resolveGitRoot(resolvedStart);
+
+  if (!gitRoot) {
+    return join(resolvedStart, ".opencode", "skills");
+  }
+
+  const localOpencodeRoot = join(gitRoot, ".opencode");
+  if (isDirectory(localOpencodeRoot)) {
+    return join(localOpencodeRoot, "skills");
+  }
+
+  const home = process.env.HOME ?? homedir();
+  return join(home, ".opencode", "skills");
+};
+
+const installBundledSkills = (destination: string) => {
   mkdirSync(destination, { recursive: true });
 
   const entries = readdirSync(BUNDLED_SKILLS_ROOT, { withFileTypes: true });
@@ -109,8 +129,12 @@ export const installCodexSkills = (destination: string) => {
   return { installed, skipped };
 };
 
-const reportCodexInstall = (destination: string, installed: string[], skipped: string[]) => {
-  process.stdout.write(`[OK] Codex skills: ${destination}\n`);
+export const installCodexSkills = (destination: string) => installBundledSkills(destination);
+
+export const installOpencodeSkills = (destination: string) => installBundledSkills(destination);
+
+const reportSkillsInstall = (label: string, destination: string, installed: string[], skipped: string[]) => {
+  process.stdout.write(`[OK] ${label} skills: ${destination}\n`);
 
   for (const skill of installed) {
     process.stdout.write(`[OK] Installed ${skill}\n`);
@@ -121,6 +145,14 @@ const reportCodexInstall = (destination: string, installed: string[], skipped: s
   }
 };
 
+const reportCodexInstall = (destination: string, installed: string[], skipped: string[]) => {
+  reportSkillsInstall("Codex", destination, installed, skipped);
+};
+
+const reportOpencodeInstall = (destination: string, installed: string[], skipped: string[]) => {
+  reportSkillsInstall("Opencode", destination, installed, skipped);
+};
+
 const parseInitOptions = (args: string[]) => {
   if (args.length === 0) {
     return;
@@ -141,4 +173,10 @@ export const runInit = async (args: string[], startDir: string) => {
     const { installed, skipped } = installCodexSkills(destination);
     reportCodexInstall(destination, installed, skipped);
   }
+
+  if (providers.includes("opencode")) {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    const { installed, skipped } = installOpencodeSkills(destination);
+    reportOpencodeInstall(destination, installed, skipped);
+  }
 };

package/src/commands/review.test.ts

@@ -49,7 +49,7 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
 
 test("review create scaffolds REVIEW_ME from template", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C001_sample-change";
+  const changeId = "C0001_sample-change";
   const changeTitle = "Sample Change";
   seedChange(schubRoot, changeId, changeTitle);
 
@@ -72,7 +72,7 @@ test("review create scaffolds REVIEW_ME from template", () => {
 
 test("review complete creates Q&A with review content", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C002_review-complete";
+  const changeId = "C0002_review-complete";
   const changeTitle = "Review Complete";
   seedChange(schubRoot, changeId, changeTitle);
 

package/src/commands/review.ts

@@ -171,7 +171,7 @@ export const runReviewCreate = (args: string[], startDir: string) => {
 
   if (!isValidChangeId(trimmedId)) {
     throw new Error(
-      `Invalid change-id '${options.changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`,
+      `Invalid change-id '${options.changeId}'. Use kebab-case or a C-prefixed id (e.g., C0001_add-user-auth).`,
     );
   }
 

package/src/commands/tasks-create.test.ts

@@ -49,12 +49,12 @@ const writeExistingTask = (schubRoot: string, status: string, id: string, slug:
 test("tasks create scaffolds multiple task files", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli");
-  writeExistingTask(schubRoot, "backlog", "T003", "existing-task");
+  seedProposal(schubRoot, "C0001_update-cli");
+  writeExistingTask(schubRoot, "backlog", "T0003", "existing-task");
 
   const { result, stdout } = runTasksCreate(cwd, [
     "--change-id",
-    "C001_update-cli",
+    "C0001_update-cli",
     "--status",
     "ready",
     "--title",
@@ -65,8 +65,8 @@ test("tasks create scaffolds multiple task files", () => {
 
   expect(result.exitCode).toBe(0);
 
-  const firstPath = join(schubRoot, "tasks", "ready", "T004_first-task.md");
-  const secondPath = join(schubRoot, "tasks", "ready", "T005_second-task.md");
+  const firstPath = join(schubRoot, "tasks", "ready", "T0004_first-task.md");
+  const secondPath = join(schubRoot, "tasks", "ready", "T0005_second-task.md");
 
   expect(existsSync(firstPath)).toBe(true);
   expect(existsSync(secondPath)).toBe(true);
@@ -74,13 +74,13 @@ test("tasks create scaffolds multiple task files", () => {
   const firstContent = readFileSync(firstPath, "utf8");
   const template = readFileSync(taskTemplatePath, "utf8");
   const expectedFirst = template
-    .replace("{{TASK_ID}}", "T004")
+    .replace("{{TASK_ID}}", "T0004")
     .replace("{{TASK_TITLE}}", "First Task")
-    .replace("{{CHANGE_ID}}", "C001_update-cli");
+    .replace("{{CHANGE_ID}}", "C0001_update-cli");
   const expectedSecond = template
-    .replace("{{TASK_ID}}", "T005")
+    .replace("{{TASK_ID}}", "T0005")
     .replace("{{TASK_TITLE}}", "Second: Task!")
-    .replace("{{CHANGE_ID}}", "C001_update-cli");
+    .replace("{{CHANGE_ID}}", "C0001_update-cli");
 
   expect(firstContent).toBe(expectedFirst);
   expect(readFileSync(secondPath, "utf8")).toBe(expectedSecond);
@@ -92,7 +92,7 @@ test("tasks create scaffolds multiple task files", () => {
 test("tasks create prefers local template overrides", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli");
+  seedProposal(schubRoot, "C0001_update-cli");
 
   const localTemplateDir = join(schubRoot, "templates", "create-tasks");
   mkdirSync(localTemplateDir, { recursive: true });
@@ -101,7 +101,7 @@ test("tasks create prefers local template overrides", () => {
 
   const { result } = runTasksCreate(cwd, [
     "--change-id",
-    "C001_update-cli",
+    "C0001_update-cli",
     "--status",
     "ready",
     "--title",
@@ -110,12 +110,12 @@ test("tasks create prefers local template overrides", () => {
 
   expect(result.exitCode).toBe(0);
 
-  const taskPath = join(schubRoot, "tasks", "ready", "T001_local-task.md");
+  const taskPath = join(schubRoot, "tasks", "ready", "T0001_local-task.md");
   const content = readFileSync(taskPath, "utf8");
   const expected = localTemplate
-    .replace("{{TASK_ID}}", "T001")
+    .replace("{{TASK_ID}}", "T0001")
     .replace("{{TASK_TITLE}}", "Local Task")
-    .replace("{{CHANGE_ID}}", "C001_update-cli");
+    .replace("{{CHANGE_ID}}", "C0001_update-cli");
 
   expect(content).toBe(expected);
 });
@@ -123,9 +123,9 @@ test("tasks create prefers local template overrides", () => {
 test("tasks create rejects invalid status", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli");
+  seedProposal(schubRoot, "C0001_update-cli");
 
-  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_update-cli", "--status", "bad status"]);
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C0001_update-cli", "--status", "bad status"]);
 
   expect(result.exitCode).not.toBe(0);
   expect(stderr).toContain("Invalid status");
@@ -136,7 +136,7 @@ test("tasks create rejects missing proposal", () => {
   const schubRoot = join(repoRoot, ".schub");
   mkdirSync(join(schubRoot, "changes"), { recursive: true });
 
-  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_missing", "--title", "New Task"]);
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C0001_missing", "--title", "New Task"]);
 
   expect(result.exitCode).not.toBe(0);
   expect(stderr).toContain("Required change files missing");
@@ -145,9 +145,9 @@ test("tasks create rejects missing proposal", () => {
 test("tasks create rejects non-accepted proposals", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli", "Draft");
+  seedProposal(schubRoot, "C0001_update-cli", "Draft");
 
-  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_update-cli", "--title", "New Task"]);
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C0001_update-cli", "--title", "New Task"]);
 
   expect(result.exitCode).not.toBe(0);
   expect(stderr).toContain("Mark the proposal as Accepted");
@@ -156,11 +156,11 @@ test("tasks create rejects non-accepted proposals", () => {
 test("tasks create rejects schub root flags", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli");
+  seedProposal(schubRoot, "C0001_update-cli");
 
   const { result, stderr } = runTasksCreate(cwd, [
     "--change-id",
-    "C001_update-cli",
+    "C0001_update-cli",
     "--title",
     "New Task",
     "--schub-root",

package/src/commands/tasks-list.test.ts

@@ -48,44 +48,44 @@ const writeTask = (tasksRoot: string, status: string, id: string, slug: string,
 
 test("tasks list shows tasks sorted by id", () => {
   const { cwd, tasksRoot } = createTaskRepo();
-  writeTask(tasksRoot, "ready", "T010", "later-task");
-  writeTask(tasksRoot, "backlog", "T002", "middle-task");
-  writeTask(tasksRoot, "archived", "T003", "archived-task");
-  writeTask(tasksRoot, "wip", "T001", "first-task");
+  writeTask(tasksRoot, "ready", "T0010", "later-task");
+  writeTask(tasksRoot, "backlog", "T0002", "middle-task");
+  writeTask(tasksRoot, "archived", "T0003", "archived-task");
+  writeTask(tasksRoot, "wip", "T0001", "first-task");
 
   const { result, stdout } = runCli(cwd);
 
   expect(result.exitCode).toBe(0);
   const lines = stdout.trim().split("\n").filter(Boolean);
   expect(lines).toHaveLength(4);
-  expect(lines[0]).toContain("T001");
+  expect(lines[0]).toContain("T0001");
   expect(lines[0]).toContain("first task");
   expect(lines[0]).toContain("(wip)");
-  expect(lines[1]).toContain("T002");
-  expect(lines[2]).toContain("T003");
-  expect(lines[3]).toContain("T010");
+  expect(lines[1]).toContain("T0002");
+  expect(lines[2]).toContain("T0003");
+  expect(lines[3]).toContain("T0010");
 });
 
 test("tasks list filters by status", () => {
   const { cwd, tasksRoot } = createTaskRepo();
-  writeTask(tasksRoot, "ready", "T010", "later-task");
-  writeTask(tasksRoot, "backlog", "T002", "middle-task");
-  writeTask(tasksRoot, "wip", "T001", "first-task");
+  writeTask(tasksRoot, "ready", "T0010", "later-task");
+  writeTask(tasksRoot, "backlog", "T0002", "middle-task");
+  writeTask(tasksRoot, "wip", "T0001", "first-task");
 
   const { result, stdout } = runCli(cwd, ["--status", "ready,wip"]);
 
   expect(result.exitCode).toBe(0);
   const lines = stdout.trim().split("\n").filter(Boolean);
   expect(lines).toHaveLength(2);
-  expect(lines.join("\n")).toContain("T010");
-  expect(lines.join("\n")).toContain("T001");
-  expect(lines.join("\n")).not.toContain("T002");
+  expect(lines.join("\n")).toContain("T0010");
+  expect(lines.join("\n")).toContain("T0001");
+  expect(lines.join("\n")).not.toContain("T0002");
 });
 
 test("tasks list supports json output", () => {
   const { cwd, tasksRoot } = createTaskRepo();
-  writeTask(tasksRoot, "ready", "T010", "later-task");
-  writeTask(tasksRoot, "wip", "T001", "first-task");
+  writeTask(tasksRoot, "ready", "T0010", "later-task");
+  writeTask(tasksRoot, "wip", "T0001", "first-task");
 
   const { result, stdout } = runCli(cwd, ["--json"]);
 
@@ -97,11 +97,11 @@ test("tasks list supports json output", () => {
     path: string;
   }>;
   expect(tasks[0]).toMatchObject({
-    id: "T001",
+    id: "T0001",
     title: "first task",
     status: "wip",
   });
-  expect(tasks[0].path).toContain(".schub/tasks/wip/T001_first-task.md");
+  expect(tasks[0].path).toContain(".schub/tasks/wip/T0001_first-task.md");
 });
 
 test("tasks list shows checklist counts in text output", () => {
@@ -109,10 +109,10 @@ test("tasks list shows checklist counts in text output", () => {
   writeTask(
     tasksRoot,
     "wip",
-    "T001",
+    "T0001",
     "first-task",
     [
-      "# Task: T001 First task",
+      "# Task: T0001 First task",
       "",
       "## Steps",
       "- [ ] Draft outline",
@@ -123,17 +123,17 @@ test("tasks list shows checklist counts in text output", () => {
       "",
     ].join("\n"),
   );
-  writeTask(tasksRoot, "backlog", "T002", "second-task");
+  writeTask(tasksRoot, "backlog", "T0002", "second-task");
 
   const { result, stdout } = runCli(cwd);
 
   expect(result.exitCode).toBe(0);
   const lines = stdout.trim().split("\n").filter(Boolean);
   expect(lines).toHaveLength(2);
-  expect(lines[0]).toContain("T001");
+  expect(lines[0]).toContain("T0001");
   expect(lines[0]).toContain("(wip)");
   expect(lines[0]).toContain("(1/2)");
-  expect(lines[1]).toContain("T002");
+  expect(lines[1]).toContain("T0002");
   expect(lines[1]).not.toMatch(/\(\d+\/\d+\)/);
 });
 
@@ -142,11 +142,11 @@ test("tasks list json includes checklist counts", () => {
   writeTask(
     tasksRoot,
     "ready",
-    "T001",
+    "T0001",
     "first-task",
-    ["# Task: T001 First task", "", "## Steps", "- [ ] Draft outline", "- [x] Review outline", ""].join("\n"),
+    ["# Task: T0001 First task", "", "## Steps", "- [ ] Draft outline", "- [x] Review outline", ""].join("\n"),
   );
-  writeTask(tasksRoot, "ready", "T002", "second-task");
+  writeTask(tasksRoot, "ready", "T0002", "second-task");
 
   const { result, stdout } = runCli(cwd, ["--json"]);
 
@@ -160,7 +160,7 @@ test("tasks list json includes checklist counts", () => {
     checklistTotal?: number;
   }>;
   expect(tasks[0]).toMatchObject({
-    id: "T001",
+    id: "T0001",
     checklistRemaining: 1,
     checklistTotal: 2,
   });