schub 0.1.3 → 0.1.4

package/src/commands/changes.test.ts

@@ -83,7 +83,7 @@ const seedChange = (schubRoot: string, changeId: string) => {
 const seedProposal = (schubRoot: string, changeId: string, status: string, title = "Seed") => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
-  const proposal = `# Proposal - ${title}\n**Status**: ${status}\n`;
+  const proposal = `---\nstatus: ${status}\n---\n# Proposal - ${title}\n`;
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };
 
@@ -92,7 +92,7 @@ const seedTask = (schubRoot: string, status: string, taskId: string, changeId: s
   mkdirSync(taskDir, { recursive: true });
   const fileName = `${taskId}_${titleSlug}.md`;
   const taskPath = join(taskDir, fileName);
-  const taskBody = `# Task: ${taskId} Seed\n\n**Change ID**: ${changeId}\n`;
+  const taskBody = `---\nchange_id: ${changeId}\n---\n# Task: ${taskId} Seed\n`;
   writeFileSync(taskPath, taskBody, "utf8");
   return taskPath;
 };
@@ -189,7 +189,7 @@ test("changes status updates accepted proposals", () => {
 
   const proposalPath = join(schubRoot, "changes", "C0001_update-cli", "proposal.md");
   const updated = readFileSync(proposalPath, "utf8");
-  expect(updated).toContain("**Status**: Done");
+  expect(updated).toContain("status: Done");
   expect(stdout).toContain("[OK] Updated status");
 });
 
@@ -204,7 +204,7 @@ test("changes status updates WIP proposals", () => {
 
   const proposalPath = join(schubRoot, "changes", "C0001_update-cli", "proposal.md");
   const updated = readFileSync(proposalPath, "utf8");
-  expect(updated).toContain("**Status**: Done");
+  expect(updated).toContain("status: Done");
   expect(stdout).toContain("[OK] Updated status");
 });
 
@@ -252,7 +252,7 @@ test("changes archive moves change and tasks by default", () => {
 
   const proposalPath = join(archivedChangePath, "proposal.md");
   const updated = readFileSync(proposalPath, "utf8");
-  expect(updated).toContain("**Status**: Archived");
+  expect(updated).toContain("status: Archived");
 });
 
 test("changes archive skips tasks when requested", () => {
@@ -281,7 +281,7 @@ test("changes archive reports collisions and leaves tasks alone", () => {
 
   const archiveRoot = join(schubRoot, "archive", "changes", changeId);
   mkdirSync(archiveRoot, { recursive: true });
-  writeFileSync(join(archiveRoot, "proposal.md"), "# Proposal - Existing\n**Status**: Archived\n", "utf8");
+  writeFileSync(join(archiveRoot, "proposal.md"), "---\nstatus: Archived\n---\n# Proposal - Existing\n", "utf8");
 
   const { result, stderr } = runChangesArchive(cwd, ["--change-id", changeId]);
 

package/src/commands/cookbook.test.ts

@@ -37,12 +37,13 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
   const proposal = [
+    "---",
+    `change_id: ${changeId}`,
+    "created: 2024-01-01",
+    "status: Draft",
+    "---",
     `# Proposal - ${title}`,
     "",
-    `**Change ID**: \`${changeId}\``,
-    "**Created**: 2024-01-01",
-    "**Status**: Draft",
-    "",
   ].join("\n");
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };

package/src/commands/init.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
+import { ensureRoadmapFile } from "../features/roadmap";
 import { initSchubRoot, resolveGitRoot } from "../init";
 
 type ProviderId = "codex" | "opencode";
@@ -167,6 +168,10 @@ export const runInit = async (args: string[], startDir: string) => {
   const schubRoot = initSchubRoot(startDir);
   process.stdout.write(`[OK] Wrote ${schubRoot}\n`);
 
+  const roadmapResult = ensureRoadmapFile(schubRoot);
+  const roadmapStatus = roadmapResult.created ? "OK" : "SKIP";
+  process.stdout.write(`[${roadmapStatus}] Roadmap ${roadmapResult.path}\n`);
+
   const providers = await promptForProviders();
   if (providers.includes("codex")) {
     const destination = resolveCodexSkillsRoot(startDir);

package/src/commands/review.test.ts

@@ -37,12 +37,13 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
   const proposal = [
+    "---",
+    `change_id: ${changeId}`,
+    "created: 2024-01-01",
+    "status: Draft",
+    "---",
     `# Proposal - ${title}`,
     "",
-    `**Change ID**: \`${changeId}\``,
-    "**Created**: 2024-01-01",
-    "**Status**: Draft",
-    "",
   ].join("\n");
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };

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., C0001_add-user-auth).`,
+      `Invalid change-id '${options.changeId}'. Use kebab-case or a C-prefixed id (e.g., C1_add-user-auth).`,
     );
   }
 

package/src/commands/roadmap.test.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { 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 runRoadmap = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "roadmap", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createRoadmapRepo = (items: string[] = []) => {
+  const base = mkdtempSync(join(tmpdir(), "schub-roadmap-cli-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+
+  const schubDir = join(repoRoot, ".schub");
+  mkdirSync(schubDir, { recursive: true });
+  const roadmapPath = join(schubDir, "roadmap.md");
+  const content = ["## Roadmap", "", ...items, ""].join("\n");
+  writeFileSync(roadmapPath, content, "utf8");
+
+  return { cwd, roadmapPath, schubDir };
+};
+
+test("roadmap list prints index and proposal refs", () => {
+  const { cwd } = createRoadmapRepo([
+    "- **<PROPOSAL_REF>**: As a user, I want to sign in.",
+    "- **C0001**: As an admin, I want to manage accounts.",
+  ]);
+
+  const { result, stdout } = runRoadmap(cwd, ["list"]);
+
+  expect(result.exitCode).toBe(0);
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toEqual(["1 [--] As a user, I want to sign in.", "2 [C0001] As an admin, I want to manage accounts."]);
+});
+
+test("roadmap add appends a new story", () => {
+  const { cwd, roadmapPath } = createRoadmapRepo(["- **<PROPOSAL_REF>**: As a user, I want to sign in."]);
+
+  const { result } = runRoadmap(cwd, ["add", "As a guest, I want to browse."]);
+
+  expect(result.exitCode).toBe(0);
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **<PROPOSAL_REF>**: As a guest, I want to browse.");
+});
+
+test("roadmap propose creates proposal and updates roadmap", () => {
+  const { cwd, roadmapPath, schubDir } = createRoadmapRepo(["- **<PROPOSAL_REF>**: As a user, I want to sign in."]);
+
+  const { result } = runRoadmap(cwd, ["propose", "1"]);
+
+  expect(result.exitCode).toBe(0);
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **C0001**: As a user, I want to sign in.");
+
+  const changeDirs = readdirSync(join(schubDir, "changes"));
+  expect(changeDirs).toHaveLength(1);
+  expect(changeDirs[0]).toMatch(/^C0001_/);
+});
+
+test("roadmap propose errors when item already linked", () => {
+  const { cwd } = createRoadmapRepo(["- **C0003**: As a user, I want to sign in."]);
+
+  const { result, stderr } = runRoadmap(cwd, ["propose", "1"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("already has a proposal ref");
+});

package/src/commands/roadmap.ts

@@ -0,0 +1,84 @@
+import { addRoadmapItem, listRoadmapItems, proposeRoadmapItem } from "../features/roadmap";
+import { findSchubRoot } from "../features/tasks";
+
+const resolveRoadmapRoot = (startDir: string) => {
+  const schubDir = findSchubRoot(startDir);
+  if (!schubDir) {
+    throw new Error("No .schub directory found.");
+  }
+  return schubDir;
+};
+
+const parseRoadmapAddOptions = (args: string[]) => {
+  const storyParts: string[] = [];
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    storyParts.push(arg);
+  }
+
+  const story = storyParts.join(" ").trim();
+  if (!story) {
+    throw new Error("Provide a roadmap story.");
+  }
+  return { story };
+};
+
+const parseRoadmapListOptions = (args: string[]) => {
+  if (args.length > 0) {
+    throw new Error(`Unknown option(s): ${args.join(", ")}`);
+  }
+};
+
+const parseRoadmapProposeOptions = (args: string[]) => {
+  if (args.length === 0) {
+    throw new Error("Provide a roadmap item index.");
+  }
+  if (args.length > 1) {
+    throw new Error(`Unknown option(s): ${args.slice(1).join(", ")}`);
+  }
+  const rawIndex = args[0];
+  if (!rawIndex || rawIndex.startsWith("--")) {
+    throw new Error("Provide a roadmap item index.");
+  }
+  const index = Number.parseInt(rawIndex, 10);
+  if (Number.isNaN(index) || index <= 0) {
+    throw new Error(`Invalid roadmap index '${rawIndex}'. Use a positive number.`);
+  }
+  return { index };
+};
+
+const formatRoadmapLine = (index: number, proposalRef: string | null, story: string) => {
+  const ref = proposalRef ?? "--";
+  return `${index} [${ref}] ${story}`;
+};
+
+export const runRoadmapList = (startDir: string, args: string[]) => {
+  parseRoadmapListOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  const items = listRoadmapItems(schubDir);
+
+  if (items.length === 0) {
+    process.stdout.write("No roadmap items found.\n");
+    return;
+  }
+
+  const lines = items.map((item) => formatRoadmapLine(item.index, item.proposalRef, item.story));
+  process.stdout.write(`${lines.join("\n")}\n`);
+};
+
+export const runRoadmapAdd = (startDir: string, args: string[]) => {
+  const options = parseRoadmapAddOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  addRoadmapItem(schubDir, options.story);
+  process.stdout.write("[OK] Added roadmap item.\n");
+};
+
+export const runRoadmapPropose = (startDir: string, args: string[]) => {
+  const options = parseRoadmapProposeOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  const result = proposeRoadmapItem(schubDir, options.index);
+  process.stdout.write(`[OK] Wrote proposal: ${result.proposalPath}\n`);
+  process.stdout.write(`[OK] Updated roadmap item ${options.index} -> ${result.proposalRef}\n`);
+};

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) => {

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`);
+};