@sduck/sduck-cli 0.1.8 → 0.2.0

package/dist/cli.js

@@ -3,8 +3,8 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/core/archive.ts
-import { readFile as readFile2, rename } from "fs/promises";
+// src/core/abandon.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { join as join3 } from "path";
 
 // src/core/fs.ts
@@ -34,12 +34,17 @@ async function copyFileIntoPlace(sourcePath, targetPath) {
   await copyFile(sourcePath, targetPath);
 }
 
+// src/core/state.ts
+import { readFile, writeFile } from "fs/promises";
+
 // src/core/project-paths.ts
 import { join, relative } from "path";
 var SDUCK_HOME_DIR = ".sduck";
 var SDUCK_ASSETS_DIR = "sduck-assets";
 var SDUCK_WORKSPACE_DIR = "sduck-workspace";
 var SDUCK_ARCHIVE_DIR = "sduck-archive";
+var SDUCK_STATE_FILE = "sduck-state.yml";
+var SDUCK_WORKTREES_DIR = ".sduck-worktrees";
 var PROJECT_SDUCK_HOME_RELATIVE_PATH = SDUCK_HOME_DIR;
 var PROJECT_SDUCK_ASSETS_RELATIVE_PATH = join(SDUCK_HOME_DIR, SDUCK_ASSETS_DIR);
 var PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH = join(SDUCK_HOME_DIR, SDUCK_WORKSPACE_DIR);
@@ -62,19 +67,82 @@ function getProjectRelativeSduckAssetPath(...segments) {
 function getProjectRelativeSduckWorkspacePath(...segments) {
   return join(PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH, ...segments);
 }
+function getProjectSduckStatePath(projectRoot) {
+  return join(projectRoot, SDUCK_HOME_DIR, SDUCK_STATE_FILE);
+}
+function getProjectWorktreePath(projectRoot, workId) {
+  return join(projectRoot, SDUCK_WORKTREES_DIR, workId);
+}
 function toBundledAssetRelativePath(projectRelativeAssetPath) {
   return relative(PROJECT_SDUCK_ASSETS_RELATIVE_PATH, projectRelativeAssetPath);
 }
 
+// src/utils/utc-date.ts
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function formatUtcDate(date) {
+  const year = String(date.getUTCFullYear());
+  const month = pad2(date.getUTCMonth() + 1);
+  const day = pad2(date.getUTCDate());
+  return `${year}-${month}-${day}`;
+}
+function formatUtcTimestamp(date) {
+  const year = String(date.getUTCFullYear());
+  const month = pad2(date.getUTCMonth() + 1);
+  const day = pad2(date.getUTCDate());
+  const hour = pad2(date.getUTCHours());
+  const minute = pad2(date.getUTCMinutes());
+  const second = pad2(date.getUTCSeconds());
+  return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`;
+}
+
+// src/core/state.ts
+async function readCurrentWorkId(projectRoot) {
+  const statePath = getProjectSduckStatePath(projectRoot);
+  if (await getFsEntryKind(statePath) !== "file") {
+    return null;
+  }
+  const content = await readFile(statePath, "utf8");
+  const match = /^current_work_id:[ \t]+(.+)$/m.exec(content);
+  const value = match?.[1]?.trim();
+  if (value === void 0 || value === "null") {
+    return null;
+  }
+  return value;
+}
+async function writeCurrentWorkId(projectRoot, workId, date = /* @__PURE__ */ new Date()) {
+  const statePath = getProjectSduckStatePath(projectRoot);
+  const idValue = workId ?? "null";
+  const content = `current_work_id: ${idValue}
+updated_at: ${formatUtcTimestamp(date)}
+`;
+  await writeFile(statePath, content, "utf8");
+}
+function throwNoCurrentWorkError(command) {
+  throw new Error(`No current work set. Run \`sduck ${command} <target>\` with explicit target.`);
+}
+
 // src/core/workspace.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2, readdir } from "fs/promises";
 import { join as join2 } from "path";
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["IN_PROGRESS", "PENDING_SPEC_APPROVAL", "PENDING_PLAN_APPROVAL"]);
+function setIfNotNull(meta, key, value) {
+  if (value !== void 0) {
+    const trimmed = value.trim();
+    if (trimmed !== "null") {
+      meta[key] = trimmed;
+    }
+  }
+}
 function parseMetaText(content) {
-  const createdAtMatch = /^created_at:\s+(.+)$/m.exec(content);
-  const idMatch = /^id:\s+(.+)$/m.exec(content);
-  const slugMatch = /^slug:\s+(.+)$/m.exec(content);
-  const statusMatch = /^status:\s+(.+)$/m.exec(content);
+  const createdAtMatch = /^created_at:[ \t]+(.+)$/m.exec(content);
+  const idMatch = /^id:[ \t]+(.+)$/m.exec(content);
+  const slugMatch = /^slug:[ \t]+(.+)$/m.exec(content);
+  const statusMatch = /^status:[ \t]+(.+)$/m.exec(content);
+  const branchMatch = /^branch:[ \t]+(.+)$/m.exec(content);
+  const baseBranchMatch = /^base_branch:[ \t]+(.+)$/m.exec(content);
+  const worktreePathMatch = /^worktree_path:[ \t]+(.+)$/m.exec(content);
+  const updatedAtMatch = /^updated_at:[ \t]+(.+)$/m.exec(content);
   const parsedMeta = {};
   if (createdAtMatch?.[1] !== void 0) {
     parsedMeta.createdAt = createdAtMatch[1].trim();
@@ -88,6 +156,10 @@ function parseMetaText(content) {
   if (statusMatch?.[1] !== void 0) {
     parsedMeta.status = statusMatch[1].trim();
   }
+  setIfNotNull(parsedMeta, "branch", branchMatch?.[1]);
+  setIfNotNull(parsedMeta, "baseBranch", baseBranchMatch?.[1]);
+  setIfNotNull(parsedMeta, "worktreePath", worktreePathMatch?.[1]);
+  setIfNotNull(parsedMeta, "updatedAt", updatedAtMatch?.[1]);
   return parsedMeta;
 }
 function sortTasksByRecency(tasks) {
@@ -97,58 +169,140 @@ function sortTasksByRecency(tasks) {
     return rightValue.localeCompare(leftValue);
   });
 }
+async function readTaskFromEntry(projectRoot, dirName) {
+  const relativePath = getProjectRelativeSduckWorkspacePath(dirName);
+  const metaPath = join2(projectRoot, relativePath, "meta.yml");
+  if (await getFsEntryKind(metaPath) !== "file") {
+    return null;
+  }
+  const parsedMeta = parseMetaText(await readFile2(metaPath, "utf8"));
+  if (parsedMeta.id === void 0 || parsedMeta.status === void 0) {
+    return null;
+  }
+  const task = {
+    id: parsedMeta.id,
+    path: relativePath,
+    status: parsedMeta.status
+  };
+  if (parsedMeta.createdAt !== void 0) {
+    task.createdAt = parsedMeta.createdAt;
+  }
+  if (parsedMeta.slug !== void 0) {
+    task.slug = parsedMeta.slug;
+  }
+  if (parsedMeta.branch !== void 0) {
+    task.branch = parsedMeta.branch;
+  }
+  if (parsedMeta.baseBranch !== void 0) {
+    task.baseBranch = parsedMeta.baseBranch;
+  }
+  if (parsedMeta.worktreePath !== void 0) {
+    task.worktreePath = parsedMeta.worktreePath;
+  }
+  if (parsedMeta.updatedAt !== void 0) {
+    task.updatedAt = parsedMeta.updatedAt;
+  }
+  return task;
+}
 async function listWorkspaceTasks(projectRoot) {
   const workspaceRoot = getProjectSduckWorkspacePath(projectRoot);
   if (await getFsEntryKind(workspaceRoot) !== "directory") {
     return [];
   }
-  const { readdir } = await import("fs/promises");
   const entries = await readdir(workspaceRoot, { withFileTypes: true });
+  const dirNames = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const results = await Promise.allSettled(
+    dirNames.map((dirName) => readTaskFromEntry(projectRoot, dirName))
+  );
   const tasks = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const relativePath = getProjectRelativeSduckWorkspacePath(entry.name);
-    const metaPath = join2(projectRoot, relativePath, "meta.yml");
-    if (await getFsEntryKind(metaPath) !== "file") {
-      continue;
-    }
-    const parsedMeta = parseMetaText(await readFile(metaPath, "utf8"));
-    if (parsedMeta.id !== void 0 && parsedMeta.status !== void 0) {
-      const task = {
-        id: parsedMeta.id,
-        path: relativePath,
-        status: parsedMeta.status
-      };
-      if (parsedMeta.createdAt !== void 0) {
-        task.createdAt = parsedMeta.createdAt;
-      }
-      if (parsedMeta.slug !== void 0) {
-        task.slug = parsedMeta.slug;
-      }
-      tasks.push(task);
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value !== null) {
+      tasks.push(result.value);
     }
   }
   return sortTasksByRecency(tasks);
 }
-async function findActiveTask(projectRoot) {
+
+// src/core/abandon.ts
+var ABANDONABLE_STATUSES = /* @__PURE__ */ new Set([
+  "PENDING_SPEC_APPROVAL",
+  "PENDING_PLAN_APPROVAL",
+  "IN_PROGRESS",
+  "REVIEW_READY",
+  "SPEC_APPROVED"
+]);
+async function resolveAbandonTarget(projectRoot, target) {
   const tasks = await listWorkspaceTasks(projectRoot);
-  for (const task of tasks) {
-    if (ACTIVE_STATUSES.has(task.status)) {
-      return {
-        id: task.id,
-        path: task.path,
-        status: task.status
-      };
+  const trimmed = target.trim();
+  const idMatch = tasks.find((task) => task.id === trimmed);
+  if (idMatch !== void 0) {
+    if (!ABANDONABLE_STATUSES.has(idMatch.status)) {
+      throw new Error(
+        `Cannot abandon work ${idMatch.id}: status is ${idMatch.status}. Only active works can be abandoned.`
+      );
     }
+    return idMatch;
+  }
+  const slugMatches = tasks.filter((task) => task.slug === trimmed);
+  if (slugMatches.length === 1) {
+    const match = slugMatches[0];
+    if (match === void 0) {
+      throw new Error(`No work matches '${trimmed}'.`);
+    }
+    if (!ABANDONABLE_STATUSES.has(match.status)) {
+      throw new Error(
+        `Cannot abandon work ${match.id}: status is ${match.status}. Only active works can be abandoned.`
+      );
+    }
+    return match;
+  }
+  if (slugMatches.length > 1) {
+    const candidates = slugMatches.map((task) => task.id).join(", ");
+    throw new Error(
+      `Multiple works match slug '${trimmed}': ${candidates}. Use \`sduck abandon <id>\` to specify.`
+    );
+  }
+  throw new Error(`No work matches '${trimmed}'.`);
+}
+async function runAbandonWorkflow(projectRoot, target, date = /* @__PURE__ */ new Date()) {
+  const work = await resolveAbandonTarget(projectRoot, target);
+  const metaPath = join3(projectRoot, work.path, "meta.yml");
+  if (await getFsEntryKind(metaPath) !== "file") {
+    throw new Error(`Missing meta.yml for work ${work.id}.`);
+  }
+  const metaContent = await readFile3(metaPath, "utf8");
+  const updatedContent = metaContent.replace(/^status:\s+.+$/m, "status: ABANDONED").replace(/^updated_at:\s+.+$/m, `updated_at: ${formatUtcTimestamp(date)}`);
+  await writeFile2(metaPath, updatedContent, "utf8");
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId === work.id) {
+    await writeCurrentWorkId(projectRoot, null, date);
+  }
+  return { workId: work.id };
+}
+
+// src/commands/abandon.ts
+async function runAbandonCommand(target, projectRoot) {
+  try {
+    const { workId } = await runAbandonWorkflow(projectRoot, target);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: `\uC791\uC5C5 \uC911\uB2E8\uB428: ${workId}`
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown abandon failure.",
+      stdout: ""
+    };
   }
-  return null;
 }
 
 // src/core/archive.ts
+import { readFile as readFile4, rename } from "fs/promises";
+import { join as join4 } from "path";
 function extractCompletedAt(metaContent) {
-  const match = /^completed_at:\s+(.+)$/m.exec(metaContent);
+  const match = /^completed_at:[ \t]+(.+)$/m.exec(metaContent);
   const value = match?.[1]?.trim();
   if (value === void 0 || value === "null") {
     return null;
@@ -162,7 +316,7 @@ function filterArchiveCandidates(tasks) {
   return tasks.filter((task) => task.status === "DONE");
 }
 async function isAlreadyArchived(archivePath, taskDirName) {
-  const targetPath = join3(archivePath, taskDirName);
+  const targetPath = join4(archivePath, taskDirName);
   return await getFsEntryKind(targetPath) === "directory";
 }
 async function loadArchiveTargets(projectRoot, input) {
@@ -170,8 +324,8 @@ async function loadArchiveTargets(projectRoot, input) {
   const doneTasks = filterArchiveCandidates(tasks);
   const targets = [];
   for (const task of doneTasks) {
-    const metaPath = join3(projectRoot, task.path, "meta.yml");
-    const metaContent = await readFile2(metaPath, "utf8");
+    const metaPath = join4(projectRoot, task.path, "meta.yml");
+    const metaContent = await readFile4(metaPath, "utf8");
     const completedAt = extractCompletedAt(metaContent);
     if (completedAt === null) {
       continue;
@@ -196,7 +350,7 @@ async function runArchiveWorkflow(projectRoot, targets) {
   const archived = [];
   const skipped = [];
   for (const target of targets) {
-    const monthDir = join3(archiveRoot, target.month);
+    const monthDir = join4(archiveRoot, target.month);
     await ensureDirectory(monthDir);
     const segments = target.path.split("/");
     const taskDirName = segments.at(-1) ?? target.id;
@@ -204,8 +358,8 @@ async function runArchiveWorkflow(projectRoot, targets) {
       skipped.push({ reason: "already archived", taskId: target.id });
       continue;
     }
-    const sourcePath = join3(projectRoot, target.path);
-    const destPath = join3(monthDir, taskDirName);
+    const sourcePath = join4(projectRoot, target.path);
+    const destPath = join4(monthDir, taskDirName);
     await rename(sourcePath, destPath);
     archived.push({ month: target.month, taskId: target.id });
   }
@@ -264,34 +418,236 @@ async function runArchiveCommand(input, projectRoot) {
   }
 }
 
-// src/core/done.ts
-import { readFile as readFile3, writeFile } from "fs/promises";
-import { join as join4 } from "path";
+// src/core/clean.ts
+import { readFile as readFile5, readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
 
-// src/utils/utc-date.ts
-function pad2(value) {
-  return String(value).padStart(2, "0");
+// src/core/git.ts
+import { execFile } from "child_process";
+function execGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile("git", [...args], { cwd }, (error, stdout, stderr) => {
+      if (error !== null) {
+        const command = args[0] ?? "unknown";
+        reject(new Error(`git ${command} failed: ${stderr.trim() || error.message}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
 }
-function formatUtcDate(date) {
-  const year = String(date.getUTCFullYear());
-  const month = pad2(date.getUTCMonth() + 1);
-  const day = pad2(date.getUTCDate());
-  return `${year}-${month}-${day}`;
+async function getCurrentBranch(cwd) {
+  const branch = await execGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (branch === "HEAD") {
+    throw new Error(
+      "Detached HEAD state. Cannot determine base branch. Use --no-git to skip worktree creation."
+    );
+  }
+  return branch;
 }
-function formatUtcTimestamp(date) {
-  const year = String(date.getUTCFullYear());
-  const month = pad2(date.getUTCMonth() + 1);
-  const day = pad2(date.getUTCDate());
-  const hour = pad2(date.getUTCHours());
-  const minute = pad2(date.getUTCMinutes());
-  const second = pad2(date.getUTCSeconds());
-  return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`;
+async function addWorktree(worktreePath, branch, baseBranch, cwd) {
+  await execGit(["worktree", "add", worktreePath, "-b", branch, baseBranch], cwd);
+}
+async function removeWorktree(worktreePath, cwd) {
+  await execGit(["worktree", "remove", worktreePath], cwd);
+}
+async function isBranchMerged(branch, baseBranch, cwd) {
+  const output = await execGit(["branch", "--merged", baseBranch], cwd);
+  const branches = output.split("\n").map((line) => line.replace(/^\*?\s*/, "").trim());
+  return branches.includes(branch);
+}
+async function deleteBranch(branch, force, cwd) {
+  const flag = force ? "-D" : "-d";
+  await execGit(["branch", flag, branch], cwd);
+}
+
+// src/core/clean.ts
+var CLEANABLE_STATUSES = /* @__PURE__ */ new Set(["DONE", "ABANDONED"]);
+async function readTasksFromDirectory(_projectRoot, dirPath, relativeDirPath) {
+  if (await getFsEntryKind(dirPath) !== "directory") {
+    return [];
+  }
+  const entries = await readdir2(dirPath, { withFileTypes: true });
+  const tasks = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const metaPath = join5(dirPath, entry.name, "meta.yml");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      continue;
+    }
+    const content = await readFile5(metaPath, "utf8");
+    const meta = parseMetaText(content);
+    if (meta.id !== void 0 && meta.status !== void 0) {
+      const task = {
+        id: meta.id,
+        path: join5(relativeDirPath, entry.name),
+        status: meta.status
+      };
+      if (meta.baseBranch !== void 0) task.baseBranch = meta.baseBranch;
+      if (meta.branch !== void 0) task.branch = meta.branch;
+      if (meta.slug !== void 0) task.slug = meta.slug;
+      if (meta.worktreePath !== void 0) task.worktreePath = meta.worktreePath;
+      tasks.push(task);
+    }
+  }
+  return tasks;
+}
+async function readArchiveTasks(projectRoot) {
+  const archivePath = getProjectSduckArchivePath(projectRoot);
+  if (await getFsEntryKind(archivePath) !== "directory") {
+    return [];
+  }
+  const months = await readdir2(archivePath, { withFileTypes: true });
+  const tasks = [];
+  for (const month of months) {
+    if (!month.isDirectory()) {
+      continue;
+    }
+    const monthPath = join5(archivePath, month.name);
+    const relativePath = join5(".sduck/sduck-archive", month.name);
+    const monthTasks = await readTasksFromDirectory(projectRoot, monthPath, relativePath);
+    tasks.push(...monthTasks);
+  }
+  return tasks;
+}
+async function resolveCleanCandidates(projectRoot, target) {
+  if (target !== void 0 && target.trim() !== "") {
+    const trimmed = target.trim();
+    const workspacePath2 = getProjectSduckWorkspacePath(projectRoot);
+    const workspaceTasks = await readTasksFromDirectory(
+      projectRoot,
+      workspacePath2,
+      ".sduck/sduck-workspace"
+    );
+    const archiveTasks = await readArchiveTasks(projectRoot);
+    const allTasks = [...workspaceTasks, ...archiveTasks];
+    const idMatch = allTasks.find((task) => task.id === trimmed);
+    if (idMatch !== void 0) {
+      if (!CLEANABLE_STATUSES.has(idMatch.status)) {
+        throw new Error(
+          `Cannot clean work ${idMatch.id}: status is ${idMatch.status}. Only DONE or ABANDONED works can be cleaned.`
+        );
+      }
+      return [toCleanCandidate(idMatch)];
+    }
+    const slugMatches = allTasks.filter((task) => task.slug === trimmed);
+    if (slugMatches.length === 1) {
+      const match = slugMatches[0];
+      if (match === void 0) {
+        throw new Error(`No work matches '${trimmed}'.`);
+      }
+      if (!CLEANABLE_STATUSES.has(match.status)) {
+        throw new Error(
+          `Cannot clean work ${match.id}: status is ${match.status}. Only DONE or ABANDONED works can be cleaned.`
+        );
+      }
+      return [toCleanCandidate(match)];
+    }
+    if (slugMatches.length > 1) {
+      const candidates = slugMatches.map((task) => task.id).join(", ");
+      throw new Error(
+        `Multiple works match slug '${trimmed}': ${candidates}. Use \`sduck clean <id>\` to specify.`
+      );
+    }
+    throw new Error(`No work matches '${trimmed}'.`);
+  }
+  const workspacePath = getProjectSduckWorkspacePath(projectRoot);
+  const tasks = await readTasksFromDirectory(projectRoot, workspacePath, ".sduck/sduck-workspace");
+  return tasks.filter((task) => CLEANABLE_STATUSES.has(task.status)).map(toCleanCandidate);
+}
+function toCleanCandidate(task) {
+  return {
+    baseBranch: task.baseBranch ?? null,
+    branch: task.branch ?? null,
+    id: task.id,
+    path: task.path,
+    worktreePath: task.worktreePath ?? null
+  };
+}
+async function runCleanWorkflow(projectRoot, target, force = false) {
+  const candidates = await resolveCleanCandidates(projectRoot, target);
+  const cleaned = [];
+  for (const candidate of candidates) {
+    if (candidate.branch === null || candidate.baseBranch === null) {
+      cleaned.push({
+        branchDeleted: false,
+        note: "no git resources to clean (--no-git work)",
+        workId: candidate.id,
+        worktreeRemoved: false
+      });
+      continue;
+    }
+    const merged = await isBranchMerged(candidate.branch, candidate.baseBranch, projectRoot);
+    let worktreeRemoved = false;
+    if (candidate.worktreePath !== null) {
+      const absoluteWorktreePath = join5(projectRoot, candidate.worktreePath);
+      if (await getFsEntryKind(absoluteWorktreePath) === "missing") {
+        console.warn(
+          `Warning: worktree path ${candidate.worktreePath} does not exist for work ${candidate.id}.`
+        );
+      } else {
+        await removeWorktree(absoluteWorktreePath, projectRoot);
+        worktreeRemoved = true;
+      }
+    }
+    let branchDeleted = false;
+    if (merged) {
+      await deleteBranch(candidate.branch, false, projectRoot);
+      branchDeleted = true;
+    } else if (force) {
+      await deleteBranch(candidate.branch, true, projectRoot);
+      branchDeleted = true;
+    } else {
+      console.warn(
+        `Warning: branch ${candidate.branch} is not merged into ${candidate.baseBranch}. Use --force to delete.`
+      );
+    }
+    cleaned.push({
+      branchDeleted,
+      note: merged ? "cleaned (merged)" : force ? "cleaned (forced)" : "worktree removed, branch kept",
+      workId: candidate.id,
+      worktreeRemoved
+    });
+  }
+  return { cleaned };
+}
+
+// src/commands/clean.ts
+async function runCleanCommand(options, projectRoot) {
+  try {
+    const result = await runCleanWorkflow(projectRoot, options.target, options.force ?? false);
+    if (result.cleaned.length === 0) {
+      return {
+        exitCode: 0,
+        stderr: "",
+        stdout: "\uC815\uB9AC\uD560 \uC791\uC5C5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+      };
+    }
+    const lines = result.cleaned.map(
+      (row) => `${row.workId}: ${row.note}` + (row.worktreeRemoved ? " (worktree \uC81C\uAC70\uB428)" : "") + (row.branchDeleted ? " (\uBE0C\uB79C\uCE58 \uC0AD\uC81C\uB428)" : "")
+    );
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: lines.join("\n")
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown clean failure.",
+      stdout: ""
+    };
+  }
 }
 
 // src/core/done.ts
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
 var TASK_EVAL_ASSET_PATH = getProjectRelativeSduckAssetPath("eval", "task.yml");
 function filterDoneCandidates(tasks) {
-  return tasks.filter((task) => task.status === "IN_PROGRESS");
+  return tasks.filter((task) => task.status === "REVIEW_READY");
 }
 function resolveDoneTargetMatches(tasks, target) {
   if (target === void 0 || target.trim() === "") {
@@ -322,8 +678,8 @@ function parseCompletedStepNumbers(value) {
   });
 }
 function validateDoneMetaContent(metaContent) {
-  const totalMatch = /^ {2}total:\s+(.+)$/m.exec(metaContent);
-  const completedMatch = /^ {2}completed:\s+\[(.*)\]$/m.exec(metaContent);
+  const totalMatch = /^ {2}total:[ \t]+(.+)$/m.exec(metaContent);
+  const completedMatch = /^ {2}completed:[ \t]+\[(.*)\]$/m.exec(metaContent);
   if (totalMatch?.[1] === void 0 || completedMatch?.[1] === void 0) {
     throw new Error("Task meta is missing a valid steps block.");
   }
@@ -365,16 +721,29 @@ function validateDoneTarget(task) {
   if (task.status === "DONE") {
     throw new Error(`Task ${task.id} is already DONE.`);
   }
-  if (task.status !== "IN_PROGRESS") {
-    throw new Error(`Task ${task.id} is not in progress (${task.status}).`);
+  if (task.status !== "REVIEW_READY") {
+    throw new Error(
+      `Task ${task.id} is not in REVIEW_READY state (${task.status}). Run \`sduck review ready\` first.`
+    );
+  }
+}
+async function checkReviewWarning(projectRoot, task) {
+  const reviewPath = join6(projectRoot, task.path, "review.md");
+  if (await getFsEntryKind(reviewPath) !== "file") {
+    return `review.md is missing for task ${task.id}. Consider running \`sduck review ready\` to create it.`;
+  }
+  const content = await readFile6(reviewPath, "utf8");
+  if (content.trim().length === 0) {
+    return `review.md is empty for task ${task.id}.`;
   }
+  return void 0;
 }
 async function loadTaskEvalCriteria(projectRoot) {
-  const taskEvalPath = join4(projectRoot, TASK_EVAL_ASSET_PATH);
+  const taskEvalPath = join6(projectRoot, TASK_EVAL_ASSET_PATH);
   if (await getFsEntryKind(taskEvalPath) !== "file") {
     throw new Error(`Missing task evaluation asset at ${TASK_EVAL_ASSET_PATH}.`);
   }
-  const taskEvalContent = await readFile3(taskEvalPath, "utf8");
+  const taskEvalContent = await readFile6(taskEvalPath, "utf8");
   const labels = extractTaskEvalCriteriaLabels(taskEvalContent);
   if (labels.length === 0) {
     throw new Error(`Task evaluation asset has no criteria labels: ${TASK_EVAL_ASSET_PATH}.`);
@@ -383,25 +752,31 @@ async function loadTaskEvalCriteria(projectRoot) {
 }
 async function completeTask(projectRoot, task, completedAt, taskEvalCriteria) {
   validateDoneTarget(task);
-  const metaPath = join4(projectRoot, task.path, "meta.yml");
-  const specPath = join4(projectRoot, task.path, "spec.md");
+  const metaPath = join6(projectRoot, task.path, "meta.yml");
+  const specPath = join6(projectRoot, task.path, "spec.md");
   if (await getFsEntryKind(metaPath) !== "file") {
     throw new Error(`Missing meta.yml for task ${task.id}.`);
   }
   if (await getFsEntryKind(specPath) !== "file") {
     throw new Error(`Missing spec.md for task ${task.id}.`);
   }
-  const metaContent = await readFile3(metaPath, "utf8");
+  const reviewWarning = await checkReviewWarning(projectRoot, task);
+  const metaContent = await readFile6(metaPath, "utf8");
   validateDoneMetaContent(metaContent);
-  const specContent = await readFile3(specPath, "utf8");
+  const specContent = await readFile6(specPath, "utf8");
   const uncheckedItems = extractUncheckedChecklistItems(specContent);
   if (uncheckedItems.length > 0) {
     throw new Error(`Spec checklist is incomplete: ${uncheckedItems.join("; ")}`);
   }
-  await writeFile(metaPath, updateDoneBlock(metaContent, completedAt), "utf8");
+  await writeFile3(metaPath, updateDoneBlock(metaContent, completedAt), "utf8");
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId === task.id) {
+    await writeCurrentWorkId(projectRoot, null);
+  }
   return {
     completedAt,
     note: `task eval checked (${String(taskEvalCriteria.length)} criteria)`,
+    reviewWarning,
     taskEvalCriteria: [...taskEvalCriteria],
     taskId: task.id
   };
@@ -431,20 +806,20 @@ async function runDoneWorkflow(projectRoot, tasks, completedAt) {
   };
 }
 async function loadDoneTargets(projectRoot, input) {
-  const tasks = await listWorkspaceTasks(projectRoot);
-  const matches = resolveDoneTargetMatches(tasks, input.target);
   if (input.target === void 0 || input.target.trim() === "") {
-    if (matches.length === 0) {
-      throw new Error("No IN_PROGRESS task found. Run `sduck done <slug>` after choosing a task.");
+    const currentWorkId = await readCurrentWorkId(projectRoot);
+    if (currentWorkId === null) {
+      throwNoCurrentWorkError("done");
     }
-    if (matches.length > 1) {
-      const labels = matches.map((task) => task.slug ?? task.id).join(", ");
-      throw new Error(
-        `Multiple IN_PROGRESS tasks found: ${labels}. Rerun with \`sduck done <slug>\` or \`sduck done <id>\`.`
-      );
+    const tasks2 = await listWorkspaceTasks(projectRoot);
+    const match = tasks2.find((task) => task.id === currentWorkId);
+    if (match === void 0) {
+      throw new Error(`Current work ${currentWorkId} not found in workspace.`);
     }
-    return matches;
+    return [match];
   }
+  const tasks = await listWorkspaceTasks(projectRoot);
+  const matches = resolveDoneTargetMatches(tasks, input.target);
   if (matches.length === 0) {
     throw new Error(`No task matches target '${input.target.trim()}'.`);
   }
@@ -507,6 +882,11 @@ function formatSuccess(result) {
       lines.push(`task eval \uAE30\uC900: ${criteriaLabels.join(", ")}`);
     }
   }
+  for (const row of result.succeeded) {
+    if (row.reviewWarning !== void 0) {
+      lines.push(`\uACBD\uACE0: ${row.reviewWarning}`);
+    }
+  }
   lines.push(...formatFailureDetails(result.failed));
   return lines.join("\n");
 }
@@ -539,11 +919,11 @@ async function runDoneCommand(input, projectRoot) {
 import { confirm } from "@inquirer/prompts";
 
 // src/core/fast-track.ts
-import { writeFile as writeFile5 } from "fs/promises";
-import { join as join9 } from "path";
+import { writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
 
 // src/core/assets.ts
-import { dirname, join as join5 } from "path";
+import { dirname, join as join7 } from "path";
 import { fileURLToPath } from "url";
 var SUPPORTED_TASK_TYPES = [
   "build",
@@ -553,16 +933,16 @@ var SUPPORTED_TASK_TYPES = [
   "chore"
 ];
 var EVAL_ASSET_RELATIVE_PATHS = {
-  task: join5("eval", "task.yml"),
-  plan: join5("eval", "plan.yml"),
-  spec: join5("eval", "spec.yml")
+  task: join7("eval", "task.yml"),
+  plan: join7("eval", "plan.yml"),
+  spec: join7("eval", "spec.yml")
 };
 var SPEC_TEMPLATE_RELATIVE_PATHS = {
-  build: join5("types", "build.md"),
-  feature: join5("types", "feature.md"),
-  fix: join5("types", "fix.md"),
-  refactor: join5("types", "refactor.md"),
-  chore: join5("types", "chore.md")
+  build: join7("types", "build.md"),
+  feature: join7("types", "feature.md"),
+  fix: join7("types", "fix.md"),
+  refactor: join7("types", "refactor.md"),
+  chore: join7("types", "chore.md")
 };
 var INIT_ASSET_RELATIVE_PATHS = [
   EVAL_ASSET_RELATIVE_PATHS.spec,
@@ -573,8 +953,8 @@ var INIT_ASSET_RELATIVE_PATHS = [
 async function getBundledAssetsRoot() {
   const currentDirectoryPath = dirname(fileURLToPath(import.meta.url));
   const candidatePaths = [
-    join5(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets"),
-    join5(currentDirectoryPath, "..", ".sduck", "sduck-assets")
+    join7(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets"),
+    join7(currentDirectoryPath, "..", ".sduck", "sduck-assets")
   ];
   for (const candidatePath of candidatePaths) {
     if (await getFsEntryKind(candidatePath) === "directory") {
@@ -591,8 +971,8 @@ function resolveSpecTemplateRelativePath(type) {
 }
 
 // src/core/plan-approve.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
 function filterPlanApprovalCandidates(tasks) {
   return tasks.filter((task) => task.status === "SPEC_APPROVED");
 }
@@ -634,8 +1014,8 @@ async function approvePlans(projectRoot, tasks, approvedAt) {
       });
       continue;
     }
-    const metaPath = join6(projectRoot, task.path, "meta.yml");
-    const planPath = join6(projectRoot, task.path, "plan.md");
+    const metaPath = join8(projectRoot, task.path, "meta.yml");
+    const planPath = join8(projectRoot, task.path, "plan.md");
     if (await getFsEntryKind(metaPath) !== "file") {
       failed.push({ note: "missing meta.yml", taskId: task.id });
       continue;
@@ -644,18 +1024,18 @@ async function approvePlans(projectRoot, tasks, approvedAt) {
       failed.push({ note: "missing plan.md", taskId: task.id });
       continue;
     }
-    const planContent = await readFile4(planPath, "utf8");
+    const planContent = await readFile7(planPath, "utf8");
     const totalSteps = countPlanSteps(planContent);
     if (totalSteps === 0) {
       failed.push({ note: "missing valid Step headers", taskId: task.id });
       continue;
     }
     const updatedMeta = updatePlanApprovalBlock(
-      await readFile4(metaPath, "utf8"),
+      await readFile7(metaPath, "utf8"),
       approvedAt,
       totalSteps
     );
-    await writeFile2(metaPath, updatedMeta, "utf8");
+    await writeFile4(metaPath, updatedMeta, "utf8");
     succeeded.push({ note: "moved to IN_PROGRESS", steps: totalSteps, taskId: task.id });
   }
   return {
@@ -667,15 +1047,22 @@ async function approvePlans(projectRoot, tasks, approvedAt) {
 }
 async function loadPlanApprovalCandidates(projectRoot, input) {
   const tasks = await listWorkspaceTasks(projectRoot);
-  return resolvePlanApprovalCandidates(tasks, input.target);
+  if (input.target !== void 0) {
+    return resolvePlanApprovalCandidates(tasks, input.target);
+  }
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId !== null) {
+    return resolvePlanApprovalCandidates(tasks, currentWorkId);
+  }
+  return resolvePlanApprovalCandidates(tasks, void 0);
 }
 function createPlanApprovedAt(date = /* @__PURE__ */ new Date()) {
   return formatUtcTimestamp(date);
 }
 
 // src/core/spec-approve.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { join as join9 } from "path";
 function filterApprovalCandidates(tasks) {
   return tasks.filter((task) => task.status === "PENDING_SPEC_APPROVAL");
 }
@@ -710,12 +1097,12 @@ function updateSpecApprovalBlock(metaContent, approvedAt) {
 async function approveSpecs(projectRoot, tasks, approvedAt) {
   validateSpecApprovalTargets(tasks);
   for (const task of tasks) {
-    const metaPath = join7(projectRoot, task.path, "meta.yml");
+    const metaPath = join9(projectRoot, task.path, "meta.yml");
     if (await getFsEntryKind(metaPath) !== "file") {
       throw new Error(`Missing meta.yml for task ${task.id}.`);
     }
-    const updatedContent = updateSpecApprovalBlock(await readFile5(metaPath, "utf8"), approvedAt);
-    await writeFile3(metaPath, updatedContent, "utf8");
+    const updatedContent = updateSpecApprovalBlock(await readFile8(metaPath, "utf8"), approvedAt);
+    await writeFile5(metaPath, updatedContent, "utf8");
   }
   return {
     approvedAt,
@@ -725,15 +1112,63 @@ async function approveSpecs(projectRoot, tasks, approvedAt) {
 }
 async function loadSpecApprovalCandidates(projectRoot, input) {
   const tasks = await listWorkspaceTasks(projectRoot);
-  return resolveTargetCandidates(tasks, input.target);
+  if (input.target !== void 0) {
+    return resolveTargetCandidates(tasks, input.target);
+  }
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId !== null) {
+    return resolveTargetCandidates(tasks, currentWorkId);
+  }
+  return resolveTargetCandidates(tasks, void 0);
 }
 function createSpecApprovedAt(date = /* @__PURE__ */ new Date()) {
   return formatUtcTimestamp(date);
 }
 
 // src/core/start.ts
-import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { join as join8 } from "path";
+import { mkdir as mkdir2, readFile as readFile10, readdir as readdir3, rm, writeFile as writeFile7 } from "fs/promises";
+import { join as join11 } from "path";
+
+// src/core/gitignore.ts
+import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { join as join10 } from "path";
+async function ensureGitignoreEntries(projectRoot, entries) {
+  const gitignorePath = join10(projectRoot, ".gitignore");
+  const added = [];
+  const skipped = [];
+  try {
+    let content = "";
+    if (await getFsEntryKind(gitignorePath) === "file") {
+      content = await readFile9(gitignorePath, "utf8");
+    }
+    const existingLines = new Set(content.split("\n").map((line) => line.trim()));
+    const toAdd = [];
+    for (const entry of entries) {
+      if (existingLines.has(entry)) {
+        skipped.push(entry);
+      } else {
+        toAdd.push(entry);
+        added.push(entry);
+      }
+    }
+    if (toAdd.length > 0) {
+      const suffix = content.endsWith("\n") || content === "" ? "" : "\n";
+      const newContent = content + suffix + toAdd.join("\n") + "\n";
+      await writeFile6(gitignorePath, newContent, "utf8");
+    }
+    return { added, skipped };
+  } catch {
+    const manualEntries = entries.join("\n");
+    return {
+      added: [],
+      skipped: [],
+      warning: `Failed to update .gitignore. Please add the following entries manually:
+${manualEntries}`
+    };
+  }
+}
+
+// src/core/start.ts
 function normalizeSlug(input) {
   return input.trim().toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -753,12 +1188,49 @@ function createWorkspaceId(date, type, slug) {
   const minute = String(date.getUTCMinutes()).padStart(2, "0");
   return `${year}${month}${day}-${hour}${minute}-${type}-${slug}`;
 }
+async function existsInArchive(projectRoot, id) {
+  const archivePath = getProjectSduckArchivePath(projectRoot);
+  if (await getFsEntryKind(archivePath) !== "directory") {
+    return false;
+  }
+  const months = await readdir3(archivePath, { withFileTypes: true });
+  for (const month of months) {
+    if (!month.isDirectory()) {
+      continue;
+    }
+    const candidatePath = join11(archivePath, month.name, id);
+    if (await getFsEntryKind(candidatePath) !== "missing") {
+      return true;
+    }
+  }
+  return false;
+}
+async function resolveUniqueWorkspaceId(projectRoot, baseId) {
+  const workspacePath = getProjectRelativeSduckWorkspacePath(baseId);
+  const absolutePath = join11(projectRoot, workspacePath);
+  if (await getFsEntryKind(absolutePath) === "missing" && !await existsInArchive(projectRoot, baseId)) {
+    return baseId;
+  }
+  for (let suffix = 2; suffix <= 100; suffix += 1) {
+    const candidateId = `${baseId}-${String(suffix)}`;
+    const candidatePath = join11(projectRoot, getProjectRelativeSduckWorkspacePath(candidateId));
+    if (await getFsEntryKind(candidatePath) === "missing" && !await existsInArchive(projectRoot, candidateId)) {
+      return candidateId;
+    }
+  }
+  throw new Error(`Cannot resolve unique workspace id for ${baseId}: too many collisions.`);
+}
 function renderInitialMeta(input) {
   return [
     `id: ${input.id}`,
     `type: ${input.type}`,
     `slug: ${input.slug}`,
     `created_at: ${input.createdAt}`,
+    `updated_at: ${input.updatedAt}`,
+    "",
+    `branch: ${input.branch ?? "null"}`,
+    `base_branch: ${input.baseBranch ?? "null"}`,
+    `worktree_path: ${input.worktreePath ?? "null"}`,
     "",
     "status: PENDING_SPEC_APPROVAL",
     "",
@@ -780,49 +1252,69 @@ function renderInitialMeta(input) {
 }
 async function resolveSpecTemplatePath(type) {
   const assetsRoot = await getBundledAssetsRoot();
-  return join8(assetsRoot, resolveSpecTemplateRelativePath(type));
+  return join11(assetsRoot, resolveSpecTemplateRelativePath(type));
 }
 function applyTemplateDefaults(template, type, slug, currentDate) {
   const displayName = slug.replace(/-/g, " ");
   return template.replace(/\{기능명\}/g, displayName).replace(/\{버그 요약 한 줄\}/g, displayName).replace(/YYYY-MM-DD/g, formatUtcDate(currentDate)).replace(/> \*\*작성자:\*\*\s*$/m, "> **\uC791\uC131\uC790:** taehee").replace(/> \*\*연관 티켓:\*\*\s*$/m, "> **\uC5F0\uAD00 \uD2F0\uCF13:** -").replace(/^# \[(feature|fix|refactor|chore|build)\] .*/m, `# [${type}] ${displayName}`);
 }
-async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE__ */ new Date()) {
+async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE__ */ new Date(), options) {
   if (!isSupportedTaskType(rawType)) {
     throw new Error(`Unsupported type: ${rawType}`);
   }
   const slug = normalizeSlug(rawSlug);
   validateSlug(slug);
-  const activeTask = await findActiveTask(projectRoot);
-  if (activeTask !== null) {
-    throw new Error(
-      `Active task exists: ${activeTask.id} (${activeTask.status}) at ${activeTask.path}. Finish or approve it before starting a new task.`
-    );
-  }
-  const workspaceId = createWorkspaceId(currentDate, rawType, slug);
+  const baseId = createWorkspaceId(currentDate, rawType, slug);
+  const workspaceId = await resolveUniqueWorkspaceId(projectRoot, baseId);
   const workspacePath = getProjectRelativeSduckWorkspacePath(workspaceId);
-  const absoluteWorkspacePath = join8(projectRoot, workspacePath);
-  if (await getFsEntryKind(absoluteWorkspacePath) !== "missing") {
-    throw new Error(`Workspace already exists: ${workspacePath}`);
-  }
+  const absoluteWorkspacePath = join11(projectRoot, workspacePath);
   const workspaceRoot = getProjectSduckWorkspacePath(projectRoot);
   await mkdir2(workspaceRoot, { recursive: true });
   await mkdir2(absoluteWorkspacePath, { recursive: false });
+  let branch = null;
+  let baseBranch = null;
+  let worktreePath = null;
+  if (options?.noGit !== true) {
+    try {
+      baseBranch = await getCurrentBranch(projectRoot);
+      branch = `work/${rawType}/${slug}`;
+      const absoluteWorktreePath = getProjectWorktreePath(projectRoot, workspaceId);
+      worktreePath = `${SDUCK_WORKTREES_DIR}/${workspaceId}`;
+      await addWorktree(absoluteWorktreePath, branch, baseBranch, projectRoot);
+    } catch (error) {
+      await rm(absoluteWorkspacePath, { recursive: true, force: true });
+      throw error;
+    }
+  }
   const templatePath = await resolveSpecTemplatePath(rawType);
   if (await getFsEntryKind(templatePath) !== "file") {
     throw new Error(`Missing spec template for type '${rawType}' at ${templatePath}`);
   }
-  const specTemplate = await readFile6(templatePath, "utf8");
+  const specTemplate = await readFile10(templatePath, "utf8");
   const specContent = applyTemplateDefaults(specTemplate, rawType, slug, currentDate);
+  const timestamp = formatUtcTimestamp(currentDate);
   const metaContent = renderInitialMeta({
-    createdAt: formatUtcTimestamp(currentDate),
+    baseBranch,
+    branch,
+    createdAt: timestamp,
     id: workspaceId,
     slug,
-    type: rawType
+    type: rawType,
+    updatedAt: timestamp,
+    worktreePath
   });
-  await writeFile4(join8(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
-  await writeFile4(join8(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
-  await writeFile4(join8(absoluteWorkspacePath, "plan.md"), "", "utf8");
+  await writeFile7(join11(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
+  await writeFile7(join11(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
+  await writeFile7(join11(absoluteWorkspacePath, "plan.md"), "", "utf8");
+  const sduckHome = getProjectSduckHomePath(projectRoot);
+  await mkdir2(sduckHome, { recursive: true });
+  await writeCurrentWorkId(projectRoot, workspaceId, currentDate);
+  const gitignoreResult = await ensureGitignoreEntries(projectRoot, [
+    `${SDUCK_WORKTREES_DIR}/`,
+    ".sduck/sduck-state.yml"
+  ]);
   return {
+    gitignoreWarning: gitignoreResult.warning,
     workspaceId,
     workspacePath,
     status: "PENDING_SPEC_APPROVAL"
@@ -883,22 +1375,28 @@ function renderMinimalPlan(slug) {
 function isInteractiveApprovalAvailable() {
   return process.stdin.isTTY && process.stdout.isTTY;
 }
-async function createFastTrackTask(input, projectRoot) {
+async function createFastTrackTask(input, projectRoot, startOptions) {
   if (!isSupportedTaskType(input.type)) {
     throw new Error(`Unsupported type: ${input.type}`);
   }
-  const startedTask = await startTask(input.type, input.slug, projectRoot);
-  const taskPath = join9(projectRoot, startedTask.workspacePath);
-  const specPath = join9(taskPath, "spec.md");
-  const planPath = join9(taskPath, "plan.md");
+  const startedTask = await startTask(
+    input.type,
+    input.slug,
+    projectRoot,
+    /* @__PURE__ */ new Date(),
+    startOptions
+  );
+  const taskPath = join12(projectRoot, startedTask.workspacePath);
+  const specPath = join12(taskPath, "spec.md");
+  const planPath = join12(taskPath, "plan.md");
   if (await getFsEntryKind(specPath) !== "file") {
     throw new Error(`Missing spec.md for fast-track task ${startedTask.workspaceId}.`);
   }
   if (await getFsEntryKind(planPath) !== "file") {
     throw new Error(`Missing plan.md for fast-track task ${startedTask.workspaceId}.`);
   }
-  await writeFile5(specPath, renderMinimalSpec(input.type, input.slug), "utf8");
-  await writeFile5(planPath, renderMinimalPlan(input.slug), "utf8");
+  await writeFile8(specPath, renderMinimalSpec(input.type, input.slug), "utf8");
+  await writeFile8(planPath, renderMinimalPlan(input.slug), "utf8");
   return {
     failed: [],
     nextStatus: "PENDING_SPEC_APPROVAL",
@@ -956,9 +1454,9 @@ async function approveFastTrackTask(target, projectRoot) {
 function formatFailures(rows) {
   return rows.map((row) => `- ${row.taskId}: ${row.note}`);
 }
-async function runFastTrackCommand(input, projectRoot) {
+async function runFastTrackCommand(input, projectRoot, startOptions) {
   try {
-    const createdTask = await createFastTrackTask(input, projectRoot);
+    const createdTask = await createFastTrackTask(input, projectRoot, startOptions);
     const lines = [
       "fast-track task created",
       `\uACBD\uB85C: ${createdTask.path}/`,
@@ -1023,16 +1521,86 @@ async function runFastTrackCommand(input, projectRoot) {
   }
 }
 
+// src/core/implement.ts
+import { readFile as readFile11 } from "fs/promises";
+import { join as join13 } from "path";
+async function resolveImplementContext(projectRoot) {
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId === null) {
+    throwNoCurrentWorkError("implement");
+  }
+  const workspacePath = getProjectRelativeSduckWorkspacePath(currentWorkId);
+  const absolutePath = join13(projectRoot, workspacePath);
+  if (await getFsEntryKind(absolutePath) !== "directory") {
+    throw new Error(
+      `Current work ${currentWorkId} not found in workspace. It may have been archived or removed.`
+    );
+  }
+  const metaPath = join13(absolutePath, "meta.yml");
+  if (await getFsEntryKind(metaPath) !== "file") {
+    throw new Error(`Missing meta.yml for work ${currentWorkId}.`);
+  }
+  const metaContent = await readFile11(metaPath, "utf8");
+  const meta = parseMetaText(metaContent);
+  return {
+    baseBranch: meta.baseBranch ?? null,
+    branch: meta.branch ?? null,
+    id: currentWorkId,
+    planPath: join13(workspacePath, "plan.md"),
+    specPath: join13(workspacePath, "spec.md"),
+    status: meta.status ?? "UNKNOWN",
+    worktreePath: meta.worktreePath ?? null
+  };
+}
+function formatImplementOutput(context) {
+  const branchDisplay = context.branch ?? "(none)";
+  const worktreeDisplay = context.worktreePath ?? "(none)";
+  const lines = [
+    `Work ID:      ${context.id}`,
+    `Branch:       ${branchDisplay}`,
+    `Worktree:     ${worktreeDisplay}`,
+    `Spec:         ${context.specPath}`,
+    `Plan:         ${context.planPath}`,
+    ""
+  ];
+  if (context.worktreePath !== null) {
+    lines.push(
+      "\uB2E4\uC74C \uBA85\uB839\uC73C\uB85C \uCF54\uB529 \uC5D0\uC774\uC804\uD2B8\uB97C \uC2DC\uC791\uD558\uC138\uC694:",
+      `  cd ${context.worktreePath}`,
+      "  claude  # \uB610\uB294 opencode / codex"
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/commands/implement.ts
+async function runImplementCommand(projectRoot) {
+  try {
+    const context = await resolveImplementContext(projectRoot);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: formatImplementOutput(context)
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown implement failure.",
+      stdout: ""
+    };
+  }
+}
+
 // src/commands/init.ts
 import { checkbox } from "@inquirer/prompts";
 
 // src/core/agent-rules.ts
-import { readFile as readFile7 } from "fs/promises";
-import { dirname as dirname2, join as join10 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { dirname as dirname2, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var CLAUDE_CODE_HOOK_SETTINGS_PATH = join10(".claude", "settings.json");
-var CLAUDE_CODE_HOOK_SCRIPT_PATH = join10(".claude", "hooks", "sdd-guard.sh");
-var CLAUDE_CODE_HOOK_SOURCE_PATH = join10("hooks", "sdd-guard.sh");
+var CLAUDE_CODE_HOOK_SETTINGS_PATH = join14(".claude", "settings.json");
+var CLAUDE_CODE_HOOK_SCRIPT_PATH = join14(".claude", "hooks", "sdd-guard.sh");
+var CLAUDE_CODE_HOOK_SOURCE_PATH = join14("hooks", "sdd-guard.sh");
 function needsClaudeCodeHook(agents) {
   return agents.includes("claude-code");
 }
@@ -1053,12 +1621,12 @@ var AGENT_RULE_TARGETS = [
   { agentId: "gemini-cli", outputPath: "GEMINI.md", kind: "root-file" },
   {
     agentId: "cursor",
-    outputPath: join10(".cursor", "rules", "sduck-core.mdc"),
+    outputPath: join14(".cursor", "rules", "sduck-core.mdc"),
     kind: "managed-file"
   },
   {
     agentId: "antigravity",
-    outputPath: join10(".agents", "rules", "sduck-core.md"),
+    outputPath: join14(".agents", "rules", "sduck-core.md"),
     kind: "managed-file"
   }
 ];
@@ -1119,8 +1687,8 @@ function renderManagedBlock(lines) {
 async function getAgentRulesAssetRoot() {
   const currentDirectoryPath = dirname2(fileURLToPath2(import.meta.url));
   const candidatePaths = [
-    join10(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets", "agent-rules"),
-    join10(currentDirectoryPath, "..", ".sduck", "sduck-assets", "agent-rules")
+    join14(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets", "agent-rules"),
+    join14(currentDirectoryPath, "..", ".sduck", "sduck-assets", "agent-rules")
   ];
   for (const candidatePath of candidatePaths) {
     if (await getFsEntryKind(candidatePath) === "directory") {
@@ -1130,7 +1698,7 @@ async function getAgentRulesAssetRoot() {
   throw new Error("Unable to locate bundled sduck agent rule assets.");
 }
 async function readAssetFile(assetRoot, fileName) {
-  return await readFile7(join10(assetRoot, fileName), "utf8");
+  return await readFile12(join14(assetRoot, fileName), "utf8");
 }
 function buildRootFileLines(agentIds, agentSpecificContent) {
   const labels = SUPPORTED_AGENTS.filter((agent) => agentIds.includes(agent.id)).map(
@@ -1192,8 +1760,8 @@ function planAgentRuleActions(mode, targets, existingEntries, existingContents)
 }
 
 // src/core/init.ts
-import { chmod, mkdir as mkdir3, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname3, join as join11 } from "path";
+import { chmod, mkdir as mkdir3, readFile as readFile13, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname3, join as join15 } from "path";
 var ASSET_TEMPLATE_DEFINITIONS = [
   {
     key: "eval-spec",
@@ -1306,7 +1874,7 @@ async function collectExistingEntries(projectRoot) {
   for (const definition of ASSET_TEMPLATE_DEFINITIONS) {
     existingEntries.set(
       definition.relativePath,
-      await getFsEntryKind(join11(projectRoot, definition.relativePath))
+      await getFsEntryKind(join15(projectRoot, definition.relativePath))
     );
   }
   return existingEntries;
@@ -1314,9 +1882,9 @@ async function collectExistingEntries(projectRoot) {
 async function collectExistingFileContents(projectRoot, targets) {
   const contents = /* @__PURE__ */ new Map();
   for (const target of targets) {
-    const targetPath = join11(projectRoot, target.outputPath);
+    const targetPath = join15(projectRoot, target.outputPath);
     if (await getFsEntryKind(targetPath) === "file") {
-      contents.set(target.outputPath, await readFile8(targetPath, "utf8"));
+      contents.set(target.outputPath, await readFile13(targetPath, "utf8"));
     }
   }
   return contents;
@@ -1379,8 +1947,8 @@ async function initProject(options, projectRoot) {
       continue;
     }
     const definition = ASSET_TEMPLATE_MAP[action.key];
-    const sourcePath = join11(assetSourceRoot, toBundledAssetRelativePath(definition.relativePath));
-    const targetPath = join11(projectRoot, definition.relativePath);
+    const sourcePath = join15(assetSourceRoot, toBundledAssetRelativePath(definition.relativePath));
+    const targetPath = join15(projectRoot, definition.relativePath);
     await ensureReadableFile(sourcePath);
     await mkdir3(dirname3(targetPath), { recursive: true });
     await copyFileIntoPlace(sourcePath, targetPath);
@@ -1390,7 +1958,7 @@ async function initProject(options, projectRoot) {
   for (const target of agentTargets) {
     agentEntryKinds.set(
       target.outputPath,
-      await getFsEntryKind(join11(projectRoot, target.outputPath))
+      await getFsEntryKind(join15(projectRoot, target.outputPath))
     );
   }
   const existingContents = await collectExistingFileContents(projectRoot, agentTargets);
@@ -1414,9 +1982,9 @@ async function initProject(options, projectRoot) {
 }
 async function installClaudeCodeHook(projectRoot, summary) {
   const assetRoot = await getBundledAssetsRoot();
-  const hookSourcePath = join11(assetRoot, "agent-rules", CLAUDE_CODE_HOOK_SOURCE_PATH);
-  const hookTargetPath = join11(projectRoot, CLAUDE_CODE_HOOK_SCRIPT_PATH);
-  const settingsPath = join11(projectRoot, CLAUDE_CODE_HOOK_SETTINGS_PATH);
+  const hookSourcePath = join15(assetRoot, "agent-rules", CLAUDE_CODE_HOOK_SOURCE_PATH);
+  const hookTargetPath = join15(projectRoot, CLAUDE_CODE_HOOK_SCRIPT_PATH);
+  const settingsPath = join15(projectRoot, CLAUDE_CODE_HOOK_SETTINGS_PATH);
   await mkdir3(dirname3(hookTargetPath), { recursive: true });
   await copyFileIntoPlace(hookSourcePath, hookTargetPath);
   await chmod(hookTargetPath, 493);
@@ -1438,32 +2006,32 @@ async function installClaudeCodeHook(projectRoot, summary) {
     }
   };
   if (await getFsEntryKind(settingsPath) === "file") {
-    const existingContent = await readFile8(settingsPath, "utf8");
+    const existingContent = await readFile13(settingsPath, "utf8");
     try {
       const existing = JSON.parse(existingContent);
       existing["hooks"] = hookConfig.hooks;
-      await writeFile6(settingsPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+      await writeFile9(settingsPath, JSON.stringify(existing, null, 2) + "\n", "utf8");
       summary.overwritten.push(CLAUDE_CODE_HOOK_SETTINGS_PATH);
       summary.rows.push({ path: CLAUDE_CODE_HOOK_SETTINGS_PATH, status: "overwritten" });
     } catch {
-      await writeFile6(settingsPath, JSON.stringify(hookConfig, null, 2) + "\n", "utf8");
+      await writeFile9(settingsPath, JSON.stringify(hookConfig, null, 2) + "\n", "utf8");
       summary.overwritten.push(CLAUDE_CODE_HOOK_SETTINGS_PATH);
       summary.rows.push({ path: CLAUDE_CODE_HOOK_SETTINGS_PATH, status: "overwritten" });
     }
   } else {
     await mkdir3(dirname3(settingsPath), { recursive: true });
-    await writeFile6(settingsPath, JSON.stringify(hookConfig, null, 2) + "\n", "utf8");
+    await writeFile9(settingsPath, JSON.stringify(hookConfig, null, 2) + "\n", "utf8");
     summary.created.push(CLAUDE_CODE_HOOK_SETTINGS_PATH);
     summary.rows.push({ path: CLAUDE_CODE_HOOK_SETTINGS_PATH, status: "created" });
   }
 }
 async function applyAgentRuleActions(projectRoot, actions, existingContents, summary, selectedAgents) {
   for (const action of actions) {
-    const targetPath = join11(projectRoot, action.outputPath);
+    const targetPath = join15(projectRoot, action.outputPath);
     const content = await renderAgentRuleContent(action, selectedAgents);
     if (action.mergeMode === "create") {
       await mkdir3(dirname3(targetPath), { recursive: true });
-      await writeFile6(targetPath, content, "utf8");
+      await writeFile9(targetPath, content, "utf8");
       summary.created.push(action.outputPath);
       summary.rows.push({ path: action.outputPath, status: "created" });
       continue;
@@ -1477,19 +2045,19 @@ async function applyAgentRuleActions(projectRoot, actions, existingContents, sum
     await mkdir3(dirname3(targetPath), { recursive: true });
     if (action.mergeMode === "prepend") {
       const currentContent = existingContents.get(action.outputPath) ?? "";
-      await writeFile6(targetPath, prependManagedBlock(currentContent, content.trimEnd()), "utf8");
+      await writeFile9(targetPath, prependManagedBlock(currentContent, content.trimEnd()), "utf8");
       summary.prepended.push(action.outputPath);
       summary.rows.push({ path: action.outputPath, status: "prepended" });
       continue;
     }
     if (action.mergeMode === "replace-block") {
       const currentContent = existingContents.get(action.outputPath) ?? "";
-      await writeFile6(targetPath, replaceManagedBlock(currentContent, content.trimEnd()), "utf8");
+      await writeFile9(targetPath, replaceManagedBlock(currentContent, content.trimEnd()), "utf8");
       summary.overwritten.push(action.outputPath);
       summary.rows.push({ path: action.outputPath, status: "overwritten" });
       continue;
     }
-    await writeFile6(targetPath, content, "utf8");
+    await writeFile9(targetPath, content, "utf8");
     summary.overwritten.push(action.outputPath);
     summary.rows.push({ path: action.outputPath, status: "overwritten" });
   }
@@ -1667,10 +2235,10 @@ async function runPlanApproveCommand(input, projectRoot) {
 }
 
 // src/core/reopen.ts
-import { copyFile as copyFile2, readFile as readFile9, unlink, writeFile as writeFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { copyFile as copyFile2, readFile as readFile14, unlink, writeFile as writeFile10 } from "fs/promises";
+import { join as join16 } from "path";
 function getCurrentCycle(metaContent) {
-  const match = /^cycle:\s+(\d+)$/m.exec(metaContent);
+  const match = /^cycle:[ \t]+(\d+)$/m.exec(metaContent);
   if (match?.[1] === void 0) {
     return 1;
   }
@@ -1751,17 +2319,17 @@ ${formatCandidateList(slugMatch)}`
   throw new Error(`No DONE task found matching '${trimmedTarget}'.`);
 }
 async function snapshotHistoryFiles(taskDir, currentCycle) {
-  const historyDir = join12(taskDir, "history");
+  const historyDir = join16(taskDir, "history");
   const created = [];
   const filesToSnapshot = ["spec.md", "plan.md"];
   const snapshotPaths = [];
   for (const fileName of filesToSnapshot) {
-    const sourcePath = join12(taskDir, fileName);
+    const sourcePath = join16(taskDir, fileName);
     if (await getFsEntryKind(sourcePath) !== "file") {
       continue;
     }
     const destName = `${String(currentCycle)}_${fileName}`;
-    const destPath = join12(historyDir, destName);
+    const destPath = join16(historyDir, destName);
     if (await getFsEntryKind(destPath) !== "missing") {
       throw new Error(`History snapshot already exists: ${destPath}`);
     }
@@ -1788,15 +2356,15 @@ async function snapshotHistoryFiles(taskDir, currentCycle) {
   return created;
 }
 async function runReopenWorkflow(projectRoot, task) {
-  const taskDir = join12(projectRoot, task.path);
-  const metaPath = join12(taskDir, "meta.yml");
-  const metaContent = await readFile9(metaPath, "utf8");
+  const taskDir = join16(projectRoot, task.path);
+  const metaPath = join16(taskDir, "meta.yml");
+  const metaContent = await readFile14(metaPath, "utf8");
   const currentCycle = getCurrentCycle(metaContent);
   const newCycle = currentCycle + 1;
   const snapshots = await snapshotHistoryFiles(taskDir, currentCycle);
   const updatedMeta = buildReopenedMeta(metaContent, newCycle);
   try {
-    await writeFile7(metaPath, updatedMeta, "utf8");
+    await writeFile10(metaPath, updatedMeta, "utf8");
   } catch (error) {
     for (const path of snapshots) {
       try {
@@ -1850,6 +2418,112 @@ async function runReopenCommand(input, projectRoot) {
   }
 }
 
+// src/core/review-ready.ts
+import { readFile as readFile15, writeFile as writeFile11 } from "fs/promises";
+import { join as join17 } from "path";
+function renderReviewTemplate(workId) {
+  return [
+    `# Review: ${workId}`,
+    "",
+    "## \uBCC0\uACBD \uC694\uC57D",
+    "",
+    "- ",
+    "",
+    "## \uD14C\uC2A4\uD2B8 \uACB0\uACFC",
+    "",
+    "- ",
+    "",
+    "## \uB9AC\uBDF0 \uCCB4\uD06C\uB9AC\uC2A4\uD2B8",
+    "",
+    "- [ ] \uCF54\uB4DC \uD488\uC9C8 \uD655\uC778",
+    "- [ ] \uD14C\uC2A4\uD2B8 \uD1B5\uACFC \uD655\uC778",
+    "- [ ] \uBB38\uC11C \uC5C5\uB370\uC774\uD2B8 \uD655\uC778",
+    ""
+  ].join("\n");
+}
+async function resolveReviewTarget(projectRoot, target) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  if (target !== void 0 && target.trim() !== "") {
+    const trimmed = target.trim();
+    const idMatch = tasks.find((task) => task.id === trimmed);
+    if (idMatch !== void 0) {
+      if (idMatch.status !== "IN_PROGRESS") {
+        throw new Error(
+          `Cannot mark work ${idMatch.id} as review ready: status is ${idMatch.status}, expected IN_PROGRESS.`
+        );
+      }
+      return idMatch;
+    }
+    const slugMatches = tasks.filter((task) => task.slug === trimmed);
+    if (slugMatches.length === 1) {
+      const match2 = slugMatches[0];
+      if (match2 === void 0) {
+        throw new Error(`No work matches '${trimmed}'.`);
+      }
+      if (match2.status !== "IN_PROGRESS") {
+        throw new Error(
+          `Cannot mark work ${match2.id} as review ready: status is ${match2.status}, expected IN_PROGRESS.`
+        );
+      }
+      return match2;
+    }
+    if (slugMatches.length > 1) {
+      const candidates = slugMatches.map((task) => task.id).join(", ");
+      throw new Error(
+        `Multiple works match slug '${trimmed}': ${candidates}. Use \`sduck review ready <id>\` to specify.`
+      );
+    }
+    throw new Error(`No work matches '${trimmed}'.`);
+  }
+  const currentWorkId = await readCurrentWorkId(projectRoot);
+  if (currentWorkId === null) {
+    throwNoCurrentWorkError("review ready");
+  }
+  const match = tasks.find((task) => task.id === currentWorkId);
+  if (match === void 0) {
+    throw new Error(`Current work ${currentWorkId} not found in workspace.`);
+  }
+  if (match.status !== "IN_PROGRESS") {
+    throw new Error(
+      `Cannot mark work ${match.id} as review ready: status is ${match.status}, expected IN_PROGRESS.`
+    );
+  }
+  return match;
+}
+async function runReviewReadyWorkflow(projectRoot, target, date = /* @__PURE__ */ new Date()) {
+  const work = await resolveReviewTarget(projectRoot, target);
+  const reviewPath = join17(projectRoot, work.path, "review.md");
+  if (await getFsEntryKind(reviewPath) !== "file") {
+    await writeFile11(reviewPath, renderReviewTemplate(work.id), "utf8");
+  }
+  const metaPath = join17(projectRoot, work.path, "meta.yml");
+  if (await getFsEntryKind(metaPath) !== "file") {
+    throw new Error(`Missing meta.yml for work ${work.id}.`);
+  }
+  const metaContent = await readFile15(metaPath, "utf8");
+  const updatedContent = metaContent.replace(/^status:\s+.+$/m, "status: REVIEW_READY").replace(/^updated_at:\s+.+$/m, `updated_at: ${formatUtcTimestamp(date)}`);
+  await writeFile11(metaPath, updatedContent, "utf8");
+  return { workId: work.id };
+}
+
+// src/commands/review.ts
+async function runReviewReadyCommand(target, projectRoot) {
+  try {
+    const { workId } = await runReviewReadyWorkflow(projectRoot, target);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: `\uB9AC\uBDF0 \uC900\uBE44 \uC644\uB8CC: ${workId}`
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown review ready failure.",
+      stdout: ""
+    };
+  }
+}
+
 // src/commands/spec-approve.ts
 import { checkbox as checkbox3 } from "@inquirer/prompts";
 function formatTaskLabel2(task) {
@@ -1908,17 +2582,21 @@ async function runSpecApproveCommand(input, projectRoot) {
 }
 
 // src/commands/start.ts
-async function runStartCommand(type, slug, projectRoot) {
+async function runStartCommand(type, slug, projectRoot, options) {
   try {
-    const result = await startTask(type, slug, projectRoot);
+    const result = await startTask(type, slug, projectRoot, /* @__PURE__ */ new Date(), options);
+    const lines = [
+      "\uC791\uC5C5 \uB514\uB809\uD1A0\uB9AC \uC0DD\uC131\uB428",
+      `\uACBD\uB85C: ${result.workspacePath}/`,
+      `\uC0C1\uD0DC: ${result.status}`
+    ];
+    if (result.gitignoreWarning !== void 0) {
+      lines.push("", result.gitignoreWarning);
+    }
     return {
       exitCode: 0,
       stderr: "",
-      stdout: [
-        "\uC791\uC5C5 \uB514\uB809\uD1A0\uB9AC \uC0DD\uC131\uB428",
-        `\uACBD\uB85C: ${result.workspacePath}/`,
-        `\uC0C1\uD0DC: ${result.status}`
-      ].join("\n")
+      stdout: lines.join("\n")
     };
   } catch (error) {
     return {
@@ -1929,10 +2607,57 @@ async function runStartCommand(type, slug, projectRoot) {
   }
 }
 
+// src/core/use.ts
+async function resolveUseTarget(projectRoot, target) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  const trimmed = target.trim();
+  const idMatch = tasks.find((task) => task.id === trimmed);
+  if (idMatch !== void 0) {
+    return idMatch;
+  }
+  const slugMatches = tasks.filter((task) => task.slug === trimmed);
+  if (slugMatches.length === 1) {
+    const match = slugMatches[0];
+    if (match !== void 0) {
+      return match;
+    }
+  }
+  if (slugMatches.length > 1) {
+    const candidates = slugMatches.map((task) => task.id).join(", ");
+    throw new Error(
+      `Multiple works match slug '${trimmed}': ${candidates}. Use \`sduck use <id>\` to specify.`
+    );
+  }
+  throw new Error(`No work matches '${trimmed}'.`);
+}
+async function runUseWorkflow(projectRoot, target) {
+  const work = await resolveUseTarget(projectRoot, target);
+  await writeCurrentWorkId(projectRoot, work.id);
+  return { workId: work.id };
+}
+
+// src/commands/use.ts
+async function runUseCommand(target, projectRoot) {
+  try {
+    const { workId } = await runUseWorkflow(projectRoot, target);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: `\uD604\uC7AC \uC791\uC5C5 \uC804\uD658: ${workId}`
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown use failure.",
+      stdout: ""
+    };
+  }
+}
+
 // package.json
 var package_default = {
   name: "@sduck/sduck-cli",
-  version: "0.1.8",
+  version: "0.2.0",
   description: "Spec-Driven Development CLI bootstrap",
   type: "module",
   bin: {
@@ -2021,8 +2746,9 @@ program.command("init").description("Initialize the current repository for the S
 program.command("preview <name>").description("Print the normalized command name for bootstrap verification").action((name) => {
   console.log(normalizeCommandName(name));
 });
-program.command("start <type> <slug>").description("Create a new task workspace from a type template").action(async (type, slug) => {
-  const result = await runStartCommand(type, slug, process.cwd());
+program.command("start <type> <slug>").description("Create a new task workspace from a type template").option("--no-git", "Skip git worktree creation").action(async (type, slug, options) => {
+  const startOptions = options.git ? void 0 : { noGit: true };
+  const result = await runStartCommand(type, slug, process.cwd(), startOptions);
   if (result.stdout !== "") {
     console.log(result.stdout);
   }
@@ -2033,8 +2759,9 @@ program.command("start <type> <slug>").description("Create a new task workspace
     process.exitCode = result.exitCode;
   }
 });
-program.command("fast-track <type> <slug>").description("Create a minimal spec/plan task with optional bundled approval").action(async (type, slug) => {
-  const result = await runFastTrackCommand({ slug, type }, process.cwd());
+program.command("fast-track <type> <slug>").description("Create a minimal spec/plan task with optional bundled approval").option("--no-git", "Skip git worktree creation").action(async (type, slug, options) => {
+  const startOptions = options.git ? void 0 : { noGit: true };
+  const result = await runFastTrackCommand({ slug, type }, process.cwd(), startOptions);
   if (result.stdout !== "") {
     console.log(result.stdout);
   }
@@ -2110,6 +2837,67 @@ program.command("archive").description("Archive completed tasks into monthly dir
     process.exitCode = result.exitCode;
   }
 });
+program.command("use <target>").description("Switch the current active work").action(async (target) => {
+  const result = await runUseCommand(target, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("implement").description("Show implementation context for the current work").action(async () => {
+  const result = await runImplementCommand(process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("abandon <target>").description("Abandon an active work").action(async (target) => {
+  const result = await runAbandonCommand(target, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+var reviewCmd = program.command("review").description("Manage review workflow state");
+reviewCmd.command("ready [target]").description("Mark a work as review ready").action(async (target) => {
+  const result = await runReviewReadyCommand(target, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
+program.command("clean [target]").description("Clean up completed or abandoned works").option("--force", "Force delete unmerged branches").action(async (target, options) => {
+  const result = await runCleanCommand({ force: options.force, target }, process.cwd());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
 program.command("roadmap").description("Show the current bootstrap status").action(() => {
   console.log(PLACEHOLDER_MESSAGE);
 });