schub 0.1.2 → 0.1.4

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

@@ -35,7 +35,7 @@ const createRepo = () => {
 const seedProposal = (schubRoot: string, changeId: string, status = "Accepted") => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
-  writeFileSync(join(changeDir, "proposal.md"), `# Proposal - Seed\n**Status**: ${status}\n`, "utf8");
+  writeFileSync(join(changeDir, "proposal.md"), `---\nstatus: ${status}\n---\n# Proposal - Seed\n`, "utf8");
 };
 
 const writeExistingTask = (schubRoot: string, status: string, id: string, slug: string) => {
@@ -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-implement.test.ts

@@ -0,0 +1,253 @@
+import { expect, test } from "bun:test";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runTasksImplement = (schubCwd: string, args: string[], envOverrides: NodeJS.ProcessEnv = {}) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "tasks", "implement", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd, ...envOverrides },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createTaskRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-tasks-implement-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+
+  const tasksRoot = join(repoRoot, ".schub", "tasks");
+  const statuses = ["backlog", "ready", "wip", "blocked", "done", "archived"];
+
+  for (const status of statuses) {
+    mkdirSync(join(tasksRoot, status), { recursive: true });
+  }
+
+  return { base, cwd, repoRoot, tasksRoot };
+};
+
+const writeTask = (tasksRoot: string, status: string, id: string, slug: string) => {
+  const filePath = join(tasksRoot, status, `${id}_${slug}.md`);
+  writeFileSync(filePath, `# Task: ${id} ${slug}\n`, "utf8");
+  return filePath;
+};
+
+const writeOpencodeStub = (baseDir: string) => {
+  const binDir = join(baseDir, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const stubPath = join(binDir, "opencode");
+  writeFileSync(
+    stubPath,
+    [
+      "#!/usr/bin/env bash",
+      'if [ -n "$OPENCODE_LOG_FILE" ]; then',
+      '  printf "%s" "$SCHUB_CWD" > "$OPENCODE_LOG_FILE"',
+      "fi",
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+  chmodSync(stubPath, 0o755);
+  return binDir;
+};
+
+const writeGitStub = (baseDir: string) => {
+  const binDir = join(baseDir, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const stubPath = join(binDir, "git");
+  writeFileSync(stubPath, ["#!/usr/bin/env bash", "exit 1", ""].join("\n"), "utf8");
+  chmodSync(stubPath, 0o755);
+};
+
+const runGit = (repoRoot: string, args: string[]) => {
+  return spawnSync({
+    cmd: ["git", ...args],
+    cwd: repoRoot,
+  });
+};
+
+const runGitChecked = (repoRoot: string, args: string[]) => {
+  const result = runGit(repoRoot, args);
+  if (result.exitCode !== 0) {
+    const stderr = decoder.decode(result.stderr ?? new Uint8Array());
+    throw new Error(`Git command failed: git ${args.join(" ")}\n${stderr}`);
+  }
+  return result;
+};
+
+const initGitRepo = (repoRoot: string) => {
+  runGitChecked(repoRoot, ["init"]);
+  writeFileSync(join(repoRoot, "README.md"), "test", "utf8");
+  runGitChecked(repoRoot, ["add", "."]);
+  runGitChecked(repoRoot, ["-c", "user.email=schub@example.com", "-c", "user.name=Schub", "commit", "-m", "init"]);
+};
+
+const waitForFile = async (filePath: string) => {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    if (existsSync(filePath)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+
+  throw new Error(`Timed out waiting for ${filePath}`);
+};
+
+test("tasks implement --mode none moves task to wip and launches opencode from repo root", async () => {
+  const { base, cwd, repoRoot, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "ready", "T0008", "none-mode");
+
+  const logPath = join(base, "opencode-log.txt");
+  const binDir = writeOpencodeStub(base);
+  const path = [binDir, process.env.PATH ?? ""].filter(Boolean).join(delimiter);
+
+  const { result } = runTasksImplement(
+    cwd,
+    ["--id", "T0008", "--mode", "none", "--worktree-root", join(repoRoot, ".schub", "worktrees")],
+    {
+      PATH: path,
+      OPENCODE_LOG_FILE: logPath,
+    },
+  );
+
+  expect(result.exitCode).toBe(0);
+
+  const wipPath = join(tasksRoot, "wip", "T0008_none-mode.md");
+  expect(existsSync(wipPath)).toBe(true);
+  expect(existsSync(join(tasksRoot, "ready", "T0008_none-mode.md"))).toBe(false);
+
+  await waitForFile(logPath);
+  const loggedCwd = readFileSync(logPath, "utf8");
+  expect(realpathSync(loggedCwd)).toBe(realpathSync(repoRoot));
+});
+
+test("tasks implement --mode worktree creates a worktree and launches opencode from worktree root", async () => {
+  const { base, cwd, repoRoot, tasksRoot } = createTaskRepo();
+  initGitRepo(repoRoot);
+  writeTask(tasksRoot, "ready", "T0009", "worktree-mode");
+
+  const logPath = join(base, "opencode-log.txt");
+  const binDir = writeOpencodeStub(base);
+  const path = [binDir, process.env.PATH ?? ""].filter(Boolean).join(delimiter);
+
+  const { result } = runTasksImplement(cwd, ["--id", "T0009", "--mode", "worktree"], {
+    PATH: path,
+    OPENCODE_LOG_FILE: logPath,
+  });
+
+  expect(result.exitCode).toBe(0);
+
+  const wipPath = join(tasksRoot, "wip", "T0009_worktree-mode.md");
+  expect(existsSync(wipPath)).toBe(true);
+
+  const worktreePath = join(repoRoot, ".schub", "worktrees", "T0009");
+  expect(existsSync(worktreePath)).toBe(true);
+
+  const branchResult = runGit(repoRoot, ["rev-parse", "--verify", "task/T0009"]);
+  expect(branchResult.exitCode).toBe(0);
+
+  await waitForFile(logPath);
+  const loggedCwd = readFileSync(logPath, "utf8");
+  expect(realpathSync(loggedCwd)).toBe(realpathSync(worktreePath));
+});
+
+test("tasks implement --mode worktree respects --worktree-root override", async () => {
+  const { base, cwd, repoRoot, tasksRoot } = createTaskRepo();
+  initGitRepo(repoRoot);
+  writeTask(tasksRoot, "ready", "T0010", "worktree-root");
+
+  const logPath = join(base, "opencode-log.txt");
+  const binDir = writeOpencodeStub(base);
+  const path = [binDir, process.env.PATH ?? ""].filter(Boolean).join(delimiter);
+
+  const { result } = runTasksImplement(
+    cwd,
+    ["--id", "T0010", "--mode", "worktree", "--worktree-root", ".schub/custom-worktrees"],
+    {
+      PATH: path,
+      OPENCODE_LOG_FILE: logPath,
+    },
+  );
+
+  expect(result.exitCode).toBe(0);
+
+  const worktreePath = join(repoRoot, ".schub", "custom-worktrees", "T0010");
+  expect(existsSync(worktreePath)).toBe(true);
+
+  await waitForFile(logPath);
+  const loggedCwd = readFileSync(logPath, "utf8");
+  expect(realpathSync(loggedCwd)).toBe(realpathSync(worktreePath));
+});
+
+test("tasks implement --mode worktree errors when branch exists", () => {
+  const { cwd, repoRoot, tasksRoot } = createTaskRepo();
+  initGitRepo(repoRoot);
+  writeTask(tasksRoot, "ready", "T0011", "branch-exists");
+  runGitChecked(repoRoot, ["branch", "task/T0011"]);
+
+  const { result, stderr } = runTasksImplement(cwd, ["--id", "T0011", "--mode", "worktree"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Branch task/T0011 already exists");
+});
+
+test("tasks implement --mode worktree errors when worktree path exists", () => {
+  const { cwd, repoRoot, tasksRoot } = createTaskRepo();
+  initGitRepo(repoRoot);
+  writeTask(tasksRoot, "ready", "T0012", "worktree-exists");
+
+  const worktreePath = join(repoRoot, ".schub", "worktrees", "T0012");
+  mkdirSync(worktreePath, { recursive: true });
+
+  const { result, stderr } = runTasksImplement(cwd, ["--id", "T0012", "--mode", "worktree"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Worktree path already exists");
+});
+
+test("tasks implement --mode worktree falls back to none when git is unavailable", async () => {
+  const { base, cwd, repoRoot, tasksRoot } = createTaskRepo();
+  initGitRepo(repoRoot);
+  writeTask(tasksRoot, "ready", "T0013", "git-missing");
+
+  const logPath = join(base, "opencode-log.txt");
+  const binDir = writeOpencodeStub(base);
+  writeGitStub(base);
+  const path = [binDir, process.env.PATH ?? ""].filter(Boolean).join(delimiter);
+
+  const { result } = runTasksImplement(cwd, ["--id", "T0013", "--mode", "worktree"], {
+    PATH: path,
+    OPENCODE_LOG_FILE: logPath,
+  });
+
+  expect(result.exitCode).toBe(0);
+
+  const worktreePath = join(repoRoot, ".schub", "worktrees", "T0013");
+  expect(existsSync(worktreePath)).toBe(false);
+
+  await waitForFile(logPath);
+  const loggedCwd = readFileSync(logPath, "utf8");
+  expect(realpathSync(loggedCwd)).toBe(realpathSync(repoRoot));
+});
+
+test("tasks implement errors when task id is not found", () => {
+  const { cwd } = createTaskRepo();
+
+  const { result, stderr } = runTasksImplement(cwd, ["--id", "T9999", "--mode", "none"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Task T9999 not found");
+});

package/src/commands/tasks-implement.ts

@@ -0,0 +1,121 @@
+import { dirname } from "node:path";
+import { assignTaskToWip, createTaskWorktree } from "../features/tasks";
+import { launchOpencodeImplement } from "../opencode";
+
+type TaskImplementMode = "none" | "worktree";
+
+type TaskImplementOptions = {
+  taskId: string;
+  mode: TaskImplementMode;
+  worktreeRoot?: string;
+};
+
+const parseTaskImplementOptions = (args: string[]) => {
+  let taskId: string | undefined;
+  let mode: string | undefined;
+  let worktreeRoot: string | undefined;
+  const unknown: string[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--id") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --id.");
+      }
+      taskId = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--id=")) {
+      taskId = arg.slice("--id=".length);
+      continue;
+    }
+    if (arg === "--mode") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --mode.");
+      }
+      mode = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--mode=")) {
+      mode = arg.slice("--mode=".length);
+      continue;
+    }
+    if (arg === "--worktree-root") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --worktree-root.");
+      }
+      worktreeRoot = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--worktree-root=")) {
+      worktreeRoot = arg.slice("--worktree-root=".length);
+      continue;
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!taskId || taskId.trim() === "") {
+    throw new Error("Provide --id.");
+  }
+
+  if (mode !== undefined && mode.trim() === "") {
+    throw new Error("Missing value for --mode.");
+  }
+
+  if (worktreeRoot !== undefined && worktreeRoot.trim() === "") {
+    throw new Error("Missing value for --worktree-root.");
+  }
+
+  const normalizedMode = (mode ?? "none").trim().toLowerCase();
+  const allowedModes: TaskImplementMode[] = ["none", "worktree"];
+  if (!allowedModes.includes(normalizedMode as TaskImplementMode)) {
+    throw new Error(`Invalid mode '${mode}'. Use none or worktree.`);
+  }
+
+  const options: TaskImplementOptions = {
+    taskId: taskId.trim().toUpperCase(),
+    mode: normalizedMode as TaskImplementMode,
+    worktreeRoot: worktreeRoot?.trim() || undefined,
+  };
+  return options;
+};
+
+export const runTasksImplement = (schubDir: string | null, args: string[]) => {
+  if (!schubDir) {
+    throw new Error("No .schub directory found.");
+  }
+
+  const options = parseTaskImplementOptions(args);
+  const assigned = assignTaskToWip(schubDir, options.taskId);
+  const repoRoot = dirname(schubDir);
+
+  let launchRoot = repoRoot;
+
+  if (options.mode === "worktree") {
+    const worktree = createTaskWorktree({
+      repoRoot,
+      taskId: options.taskId,
+      worktreeRoot: options.worktreeRoot,
+    });
+
+    if (worktree) {
+      launchRoot = worktree.worktreePath;
+    }
+  }
+
+  launchOpencodeImplement(options.taskId, repoRoot, assigned.title, {
+    env: { ...process.env, SCHUB_CWD: launchRoot },
+  });
+
+  process.stdout.write(`[OK] Assigned task ${assigned.id}: ${assigned.status}\n`);
+};

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,
   });