@sduck/sduck-cli 0.1.0 → 0.1.2

package/dist/cli.js

@@ -3,42 +3,906 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/commands/init.ts
-import { checkbox } from "@inquirer/prompts";
+// src/core/done.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/core/fs.ts
+import { constants } from "fs";
+import { access, copyFile, mkdir, stat } from "fs/promises";
+async function getFsEntryKind(targetPath) {
+  try {
+    const stats = await stat(targetPath);
+    if (stats.isDirectory()) {
+      return "directory";
+    }
+    if (stats.isFile()) {
+      return "file";
+    }
+    return "file";
+  } catch {
+    return "missing";
+  }
+}
+async function ensureDirectory(targetPath) {
+  await mkdir(targetPath, { recursive: true });
+}
+async function ensureReadableFile(targetPath) {
+  await access(targetPath, constants.R_OK);
+}
+async function copyFileIntoPlace(sourcePath, targetPath) {
+  await copyFile(sourcePath, targetPath);
+}
+
+// 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 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);
+function getProjectSduckHomePath(projectRoot) {
+  return join(projectRoot, PROJECT_SDUCK_HOME_RELATIVE_PATH);
+}
+function getProjectSduckAssetsPath(projectRoot) {
+  return join(projectRoot, PROJECT_SDUCK_ASSETS_RELATIVE_PATH);
+}
+function getProjectSduckWorkspacePath(projectRoot) {
+  return join(projectRoot, PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH);
+}
+function getProjectRelativeSduckAssetPath(...segments) {
+  return join(PROJECT_SDUCK_ASSETS_RELATIVE_PATH, ...segments);
+}
+function getProjectRelativeSduckWorkspacePath(...segments) {
+  return join(PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH, ...segments);
+}
+function toBundledAssetRelativePath(projectRelativeAssetPath) {
+  return relative(PROJECT_SDUCK_ASSETS_RELATIVE_PATH, projectRelativeAssetPath);
+}
+
+// src/core/workspace.ts
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["IN_PROGRESS", "PENDING_SPEC_APPROVAL", "PENDING_PLAN_APPROVAL"]);
+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 parsedMeta = {};
+  if (createdAtMatch?.[1] !== void 0) {
+    parsedMeta.createdAt = createdAtMatch[1].trim();
+  }
+  if (idMatch?.[1] !== void 0) {
+    parsedMeta.id = idMatch[1].trim();
+  }
+  if (slugMatch?.[1] !== void 0) {
+    parsedMeta.slug = slugMatch[1].trim();
+  }
+  if (statusMatch?.[1] !== void 0) {
+    parsedMeta.status = statusMatch[1].trim();
+  }
+  return parsedMeta;
+}
+function sortTasksByRecency(tasks) {
+  return [...tasks].sort((left, right) => {
+    const leftValue = left.createdAt ?? "";
+    const rightValue = right.createdAt ?? "";
+    return rightValue.localeCompare(leftValue);
+  });
+}
+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 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);
+    }
+  }
+  return sortTasksByRecency(tasks);
+}
+async function findActiveTask(projectRoot) {
+  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
+      };
+    }
+  }
+  return null;
+}
+
+// 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/done.ts
+var TASK_EVAL_ASSET_PATH = getProjectRelativeSduckAssetPath("eval", "task.yml");
+function filterDoneCandidates(tasks) {
+  return tasks.filter((task) => task.status === "IN_PROGRESS");
+}
+function resolveDoneTargetMatches(tasks, target) {
+  if (target === void 0 || target.trim() === "") {
+    return filterDoneCandidates(tasks);
+  }
+  const trimmedTarget = target.trim();
+  return tasks.filter((task) => task.id === trimmedTarget || task.slug === trimmedTarget);
+}
+function extractUncheckedChecklistItems(specContent) {
+  const uncheckedMatches = specContent.matchAll(/^\s*- \[ \] (.+)$/gm);
+  return [...uncheckedMatches].map((match) => match[1]).filter((item) => item !== void 0).map((item) => item.trim());
+}
+function extractTaskEvalCriteriaLabels(taskEvalContent) {
+  const labels = [...taskEvalContent.matchAll(/^\s{6}label:\s+(.+)$/gm)].map((match) => match[1]).filter((item) => item !== void 0).map((item) => item.trim());
+  return [...new Set(labels)];
+}
+function parseCompletedStepNumbers(value) {
+  const trimmedValue = value.trim();
+  if (trimmedValue === "") {
+    return [];
+  }
+  return trimmedValue.split(",").map((segment) => {
+    const parsedValue = Number.parseInt(segment.trim(), 10);
+    if (!Number.isInteger(parsedValue)) {
+      throw new Error(`Invalid completed step value: ${segment.trim()}`);
+    }
+    return parsedValue;
+  });
+}
+function validateDoneMetaContent(metaContent) {
+  const totalMatch = /^ {2}total:\s+(.+)$/m.exec(metaContent);
+  const completedMatch = /^ {2}completed:\s+\[(.*)\]$/m.exec(metaContent);
+  if (totalMatch?.[1] === void 0 || completedMatch?.[1] === void 0) {
+    throw new Error("Task meta is missing a valid steps block.");
+  }
+  if (totalMatch[1].trim() === "null") {
+    throw new Error("Task steps are not initialized yet (steps.total is null).");
+  }
+  const totalSteps = Number.parseInt(totalMatch[1].trim(), 10);
+  if (!Number.isInteger(totalSteps) || totalSteps <= 0) {
+    throw new Error(`Task has an invalid steps.total value: ${totalMatch[1].trim()}`);
+  }
+  const completedSteps = parseCompletedStepNumbers(completedMatch[1]);
+  const uniqueSteps = new Set(completedSteps);
+  if (uniqueSteps.size !== completedSteps.length) {
+    throw new Error("Task has duplicate completed step numbers.");
+  }
+  const invalidStep = completedSteps.find((step) => step < 1 || step > totalSteps);
+  if (invalidStep !== void 0) {
+    throw new Error(`Task has an out-of-range completed step number: ${String(invalidStep)}`);
+  }
+  if (completedSteps.length !== totalSteps) {
+    const missingSteps = [];
+    for (let step = 1; step <= totalSteps; step += 1) {
+      if (!uniqueSteps.has(step)) {
+        missingSteps.push(step);
+      }
+    }
+    throw new Error(`Task steps are incomplete. Missing steps: ${missingSteps.join(", ")}`);
+  }
+  return {
+    completedSteps,
+    totalSteps
+  };
+}
+function updateDoneBlock(metaContent, completedAt) {
+  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: DONE");
+  return withStatus.replace(/^completed_at:\s+.+$/m, `completed_at: ${completedAt}`);
+}
+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}).`);
+  }
+}
+async function loadTaskEvalCriteria(projectRoot) {
+  const taskEvalPath = join3(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 readFile2(taskEvalPath, "utf8");
+  const labels = extractTaskEvalCriteriaLabels(taskEvalContent);
+  if (labels.length === 0) {
+    throw new Error(`Task evaluation asset has no criteria labels: ${TASK_EVAL_ASSET_PATH}.`);
+  }
+  return labels;
+}
+async function completeTask(projectRoot, task, completedAt, taskEvalCriteria) {
+  validateDoneTarget(task);
+  const metaPath = join3(projectRoot, task.path, "meta.yml");
+  const specPath = join3(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 readFile2(metaPath, "utf8");
+  validateDoneMetaContent(metaContent);
+  const specContent = await readFile2(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");
+  return {
+    completedAt,
+    note: `task eval checked (${String(taskEvalCriteria.length)} criteria)`,
+    taskEvalCriteria: [...taskEvalCriteria],
+    taskId: task.id
+  };
+}
+async function runDoneWorkflow(projectRoot, tasks, completedAt) {
+  const taskEvalCriteria = await loadTaskEvalCriteria(projectRoot);
+  const succeeded = [];
+  const failed = [];
+  for (const task of tasks) {
+    try {
+      succeeded.push(await completeTask(projectRoot, task, completedAt, taskEvalCriteria));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown done failure.";
+      const pendingChecklistItems = message.startsWith("Spec checklist is incomplete: ") ? message.replace("Spec checklist is incomplete: ", "").split("; ").filter((item) => item !== "") : [];
+      failed.push({
+        note: message,
+        pendingChecklistItems,
+        taskId: task.id
+      });
+    }
+  }
+  return {
+    completedAt,
+    failed,
+    nextStatus: "DONE",
+    succeeded
+  };
+}
+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.");
+    }
+    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>\`.`
+      );
+    }
+    return matches;
+  }
+  if (matches.length === 0) {
+    throw new Error(`No task matches target '${input.target.trim()}'.`);
+  }
+  if (matches.length > 1) {
+    const ids = matches.map((task) => task.id).join(", ");
+    throw new Error(`Multiple tasks match '${input.target.trim()}': ${ids}. Use an exact task id.`);
+  }
+  return matches;
+}
+function createTaskCompletedAt(date = /* @__PURE__ */ new Date()) {
+  return formatUtcTimestamp(date);
+}
+
+// src/commands/done.ts
+function padCell(value, width) {
+  return value.padEnd(width, " ");
+}
+function buildResultTable(result) {
+  const rows = [
+    ...result.succeeded.map((row) => ({
+      note: row.note,
+      result: "success",
+      task: row.taskId
+    })),
+    ...result.failed.map((row) => ({
+      note: row.note,
+      result: "failed",
+      task: row.taskId
+    }))
+  ];
+  const resultWidth = Math.max("Result".length, ...rows.map((row) => row.result.length));
+  const taskWidth = Math.max("Task".length, ...rows.map((row) => row.task.length));
+  const noteWidth = Math.max("Note".length, ...rows.map((row) => row.note.length));
+  const border = `+-${"-".repeat(resultWidth)}-+-${"-".repeat(taskWidth)}-+-${"-".repeat(noteWidth)}-+`;
+  const header = `| ${padCell("Result", resultWidth)} | ${padCell("Task", taskWidth)} | ${padCell("Note", noteWidth)} |`;
+  const body = rows.map(
+    (row) => `| ${padCell(row.result, resultWidth)} | ${padCell(row.task, taskWidth)} | ${padCell(row.note, noteWidth)} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
+}
+function formatFailureDetails(failed) {
+  const lines = [];
+  for (const row of failed) {
+    if (row.pendingChecklistItems.length === 0) {
+      continue;
+    }
+    lines.push("", `\uBBF8\uC644\uB8CC \uCCB4\uD06C\uB9AC\uC2A4\uD2B8 (${row.taskId})`);
+    for (const item of row.pendingChecklistItems) {
+      lines.push(`- [ ] ${item}`);
+    }
+  }
+  return lines;
+}
+function formatSuccess(result) {
+  const lines = [buildResultTable(result)];
+  if (result.succeeded.length > 0) {
+    const criteriaLabels = result.succeeded[0]?.taskEvalCriteria ?? [];
+    lines.push("", "\uC0C1\uD0DC: DONE");
+    if (criteriaLabels.length > 0) {
+      lines.push(`task eval \uAE30\uC900: ${criteriaLabels.join(", ")}`);
+    }
+  }
+  lines.push(...formatFailureDetails(result.failed));
+  return lines.join("\n");
+}
+async function runDoneCommand(input, projectRoot) {
+  try {
+    const tasks = await loadDoneTargets(projectRoot, input);
+    const result = await runDoneWorkflow(projectRoot, tasks, createTaskCompletedAt());
+    if (result.succeeded.length === 0) {
+      return {
+        exitCode: 1,
+        stderr: formatSuccess(result),
+        stdout: ""
+      };
+    }
+    return {
+      exitCode: result.failed.length > 0 ? 1 : 0,
+      stderr: "",
+      stdout: formatSuccess(result)
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown done failure.",
+      stdout: ""
+    };
+  }
+}
+
+// src/commands/fast-track.ts
+import { confirm } from "@inquirer/prompts";
+
+// src/core/fast-track.ts
+import { writeFile as writeFile5 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/core/assets.ts
+import { dirname, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var SUPPORTED_TASK_TYPES = [
+  "build",
+  "feature",
+  "fix",
+  "refactor",
+  "chore"
+];
+var EVAL_ASSET_RELATIVE_PATHS = {
+  task: join4("eval", "task.yml"),
+  plan: join4("eval", "plan.yml"),
+  spec: join4("eval", "spec.yml")
+};
+var SPEC_TEMPLATE_RELATIVE_PATHS = {
+  build: join4("types", "build.md"),
+  feature: join4("types", "feature.md"),
+  fix: join4("types", "fix.md"),
+  refactor: join4("types", "refactor.md"),
+  chore: join4("types", "chore.md")
+};
+var INIT_ASSET_RELATIVE_PATHS = [
+  EVAL_ASSET_RELATIVE_PATHS.spec,
+  EVAL_ASSET_RELATIVE_PATHS.plan,
+  EVAL_ASSET_RELATIVE_PATHS.task,
+  ...Object.values(SPEC_TEMPLATE_RELATIVE_PATHS)
+];
+async function getBundledAssetsRoot() {
+  const currentDirectoryPath = dirname(fileURLToPath(import.meta.url));
+  const candidatePaths = [
+    join4(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets"),
+    join4(currentDirectoryPath, "..", ".sduck", "sduck-assets")
+  ];
+  for (const candidatePath of candidatePaths) {
+    if (await getFsEntryKind(candidatePath) === "directory") {
+      return candidatePath;
+    }
+  }
+  throw new Error("Unable to locate bundled .sduck/sduck-assets directory.");
+}
+function isSupportedTaskType(value) {
+  return SUPPORTED_TASK_TYPES.includes(value);
+}
+function resolveSpecTemplateRelativePath(type) {
+  return SPEC_TEMPLATE_RELATIVE_PATHS[type];
+}
+
+// src/core/plan-approve.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+function filterPlanApprovalCandidates(tasks) {
+  return tasks.filter((task) => task.status === "SPEC_APPROVED");
+}
+function resolvePlanApprovalCandidates(tasks, target) {
+  const candidates = filterPlanApprovalCandidates(tasks);
+  if (target === void 0 || target.trim() === "") {
+    return candidates;
+  }
+  const trimmedTarget = target.trim();
+  return candidates.filter((task) => task.id === trimmedTarget || task.slug === trimmedTarget);
+}
+function countPlanSteps(planContent) {
+  const matches = planContent.match(/^## Step \d+\. .+$/gm);
+  return matches?.length ?? 0;
+}
+function updatePlanApprovalBlock(metaContent, approvedAt, totalSteps) {
+  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: IN_PROGRESS");
+  const withPlan = withStatus.replace(
+    /plan:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
+    `plan:
+  approved: true
+  approved_at: ${approvedAt}`
+  );
+  return withPlan.replace(
+    /steps:\n {2}total:\s+null\n {2}completed:\s+\[\]/m,
+    `steps:
+  total: ${String(totalSteps)}
+  completed: []`
+  );
+}
+async function approvePlans(projectRoot, tasks, approvedAt) {
+  const succeeded = [];
+  const failed = [];
+  for (const task of tasks) {
+    if (task.status !== "SPEC_APPROVED") {
+      failed.push({
+        note: `task is not awaiting plan approval (${task.status})`,
+        taskId: task.id
+      });
+      continue;
+    }
+    const metaPath = join5(projectRoot, task.path, "meta.yml");
+    const planPath = join5(projectRoot, task.path, "plan.md");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      failed.push({ note: "missing meta.yml", taskId: task.id });
+      continue;
+    }
+    if (await getFsEntryKind(planPath) !== "file") {
+      failed.push({ note: "missing plan.md", taskId: task.id });
+      continue;
+    }
+    const planContent = await readFile3(planPath, "utf8");
+    const totalSteps = countPlanSteps(planContent);
+    if (totalSteps === 0) {
+      failed.push({ note: "missing valid Step headers", taskId: task.id });
+      continue;
+    }
+    const updatedMeta = updatePlanApprovalBlock(
+      await readFile3(metaPath, "utf8"),
+      approvedAt,
+      totalSteps
+    );
+    await writeFile2(metaPath, updatedMeta, "utf8");
+    succeeded.push({ note: "moved to IN_PROGRESS", steps: totalSteps, taskId: task.id });
+  }
+  return {
+    approvedAt,
+    failed,
+    nextStatus: "IN_PROGRESS",
+    succeeded
+  };
+}
+async function loadPlanApprovalCandidates(projectRoot, input) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  return resolvePlanApprovalCandidates(tasks, input.target);
+}
+function createPlanApprovedAt(date = /* @__PURE__ */ new Date()) {
+  return formatUtcTimestamp(date);
+}
+
+// src/core/spec-approve.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+function filterApprovalCandidates(tasks) {
+  return tasks.filter((task) => task.status === "PENDING_SPEC_APPROVAL");
+}
+function resolveTargetCandidates(tasks, target) {
+  const candidates = filterApprovalCandidates(tasks);
+  if (target === void 0 || target.trim() === "") {
+    return candidates;
+  }
+  const trimmedTarget = target.trim();
+  return candidates.filter((task) => task.id === trimmedTarget || task.slug === trimmedTarget);
+}
+function validateSpecApprovalTargets(tasks) {
+  if (tasks.length === 0) {
+    throw new Error("No approvable spec tasks found.");
+  }
+  const invalidTask = tasks.find((task) => task.status !== "PENDING_SPEC_APPROVAL");
+  if (invalidTask !== void 0) {
+    throw new Error(
+      `Task ${invalidTask.id} is not awaiting spec approval (${invalidTask.status}).`
+    );
+  }
+}
+function updateSpecApprovalBlock(metaContent, approvedAt) {
+  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: SPEC_APPROVED");
+  return withStatus.replace(
+    /spec:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
+    `spec:
+  approved: true
+  approved_at: ${approvedAt}`
+  );
+}
+async function approveSpecs(projectRoot, tasks, approvedAt) {
+  validateSpecApprovalTargets(tasks);
+  for (const task of tasks) {
+    const metaPath = join6(projectRoot, task.path, "meta.yml");
+    if (await getFsEntryKind(metaPath) !== "file") {
+      throw new Error(`Missing meta.yml for task ${task.id}.`);
+    }
+    const updatedContent = updateSpecApprovalBlock(await readFile4(metaPath, "utf8"), approvedAt);
+    await writeFile3(metaPath, updatedContent, "utf8");
+  }
+  return {
+    approvedAt,
+    approvedTaskIds: tasks.map((task) => task.id),
+    nextStatus: "SPEC_APPROVED"
+  };
+}
+async function loadSpecApprovalCandidates(projectRoot, input) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  return resolveTargetCandidates(tasks, input.target);
+}
+function createSpecApprovedAt(date = /* @__PURE__ */ new Date()) {
+  return formatUtcTimestamp(date);
+}
 
-// src/core/agent-rules.ts
-import { readFile } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+// src/core/start.ts
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
+function normalizeSlug(input) {
+  return input.trim().toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function validateSlug(slug) {
+  if (slug === "") {
+    throw new Error("Invalid slug: slug cannot be empty after normalization.");
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+    throw new Error("Invalid slug: use lowercase kebab-case only.");
+  }
+}
+function createWorkspaceId(date, type, slug) {
+  const year = String(date.getUTCFullYear());
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hour = String(date.getUTCHours()).padStart(2, "0");
+  const minute = String(date.getUTCMinutes()).padStart(2, "0");
+  return `${year}${month}${day}-${hour}${minute}-${type}-${slug}`;
+}
+function renderInitialMeta(input) {
+  return [
+    `id: ${input.id}`,
+    `type: ${input.type}`,
+    `slug: ${input.slug}`,
+    `created_at: ${input.createdAt}`,
+    "",
+    "status: PENDING_SPEC_APPROVAL",
+    "",
+    "spec:",
+    "  approved: false",
+    "  approved_at: null",
+    "",
+    "plan:",
+    "  approved: false",
+    "  approved_at: null",
+    "",
+    "steps:",
+    "  total: null",
+    "  completed: []",
+    "",
+    "completed_at: null",
+    ""
+  ].join("\n");
+}
+async function resolveSpecTemplatePath(type) {
+  const assetsRoot = await getBundledAssetsRoot();
+  return join7(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()) {
+  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 workspacePath = getProjectRelativeSduckWorkspacePath(workspaceId);
+  const absoluteWorkspacePath = join7(projectRoot, workspacePath);
+  if (await getFsEntryKind(absoluteWorkspacePath) !== "missing") {
+    throw new Error(`Workspace already exists: ${workspacePath}`);
+  }
+  const workspaceRoot = getProjectSduckWorkspacePath(projectRoot);
+  await mkdir2(workspaceRoot, { recursive: true });
+  await mkdir2(absoluteWorkspacePath, { recursive: false });
+  const templatePath = await resolveSpecTemplatePath(rawType);
+  if (await getFsEntryKind(templatePath) !== "file") {
+    throw new Error(`Missing spec template for type '${rawType}' at ${templatePath}`);
+  }
+  const specTemplate = await readFile5(templatePath, "utf8");
+  const specContent = applyTemplateDefaults(specTemplate, rawType, slug, currentDate);
+  const metaContent = renderInitialMeta({
+    createdAt: formatUtcTimestamp(currentDate),
+    id: workspaceId,
+    slug,
+    type: rawType
+  });
+  await writeFile4(join7(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
+  await writeFile4(join7(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
+  await writeFile4(join7(absoluteWorkspacePath, "plan.md"), "", "utf8");
+  return {
+    workspaceId,
+    workspacePath,
+    status: "PENDING_SPEC_APPROVAL"
+  };
+}
 
-// src/core/fs.ts
-import { constants } from "fs";
-import { access, copyFile, mkdir, stat } from "fs/promises";
-async function getFsEntryKind(targetPath) {
-  try {
-    const stats = await stat(targetPath);
-    if (stats.isDirectory()) {
-      return "directory";
-    }
-    if (stats.isFile()) {
-      return "file";
+// src/core/fast-track.ts
+function toSpecApprovalTarget(target) {
+  return target;
+}
+function toPlanApprovalTarget(target) {
+  return {
+    ...target,
+    status: "SPEC_APPROVED"
+  };
+}
+function renderMinimalSpec(type, slug) {
+  const displayName = slug.replace(/-/g, " ");
+  return [
+    `# [${type}] ${displayName}`,
+    "",
+    "## \uBAA9\uD45C",
+    "",
+    `- ${displayName} \uC791\uC5C5\uC744 \uBE60\uB974\uAC8C \uC2DC\uC791\uD560 \uC218 \uC788\uB294 \uCD5C\uC18C \uC2A4\uD399\uC744 \uC815\uC758\uD55C\uB2E4`,
+    "",
+    "## \uBC94\uC704",
+    "",
+    `- ${displayName} \uAD6C\uD604\uC5D0 \uD544\uC694\uD55C \uD575\uC2EC \uBCC0\uACBD\uB9CC \uD3EC\uD568\uD55C\uB2E4`,
+    "",
+    "## \uC81C\uC678 \uBC94\uC704",
+    "",
+    "- \uC694\uAD6C\uC0AC\uD56D\uACFC \uC9C1\uC811 \uAD00\uB828 \uC5C6\uB294 \uB9AC\uD329\uD130\uB9C1\uC740 \uD3EC\uD568\uD558\uC9C0 \uC54A\uB294\uB2E4",
+    "",
+    "## \uC644\uB8CC \uC870\uAC74",
+    "",
+    "- [ ] \uD575\uC2EC \uB3D9\uC791\uC774 \uAD6C\uD604\uB41C\uB2E4",
+    "- [ ] \uAD00\uB828 \uD14C\uC2A4\uD2B8\uAC00 \uD1B5\uACFC\uD55C\uB2E4",
+    "- [ ] \uBB38\uC11C \uB610\uB294 \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC601\uD5A5\uC774 \uBC18\uC601\uB41C\uB2E4",
+    ""
+  ].join("\n");
+}
+function renderMinimalPlan(slug) {
+  const displayName = slug.replace(/-/g, " ");
+  return [
+    "# Plan",
+    "",
+    `## Step 1. ${displayName} \uC694\uAD6C\uC0AC\uD56D \uBC18\uC601`,
+    "",
+    "- \uD575\uC2EC \uAD6C\uD604 \uD30C\uC77C\uC744 \uC218\uC815\uD574 \uC694\uAD6C\uC0AC\uD56D\uC744 \uBC18\uC601\uD55C\uB2E4.",
+    "",
+    "## Step 2. \uAC80\uC99D\uACFC \uB9C8\uBB34\uB9AC",
+    "",
+    "- \uAD00\uB828 \uD14C\uC2A4\uD2B8\uC640 \uBB38\uC11C\uB97C \uC5C5\uB370\uC774\uD2B8\uD55C\uB2E4.",
+    "- `npm run lint`, `npm run typecheck`, `npm test`, `npm run build`\uB85C \uAC80\uC99D\uD55C\uB2E4.",
+    ""
+  ].join("\n");
+}
+function isInteractiveApprovalAvailable() {
+  return process.stdin.isTTY && process.stdout.isTTY;
+}
+async function createFastTrackTask(input, projectRoot) {
+  if (!isSupportedTaskType(input.type)) {
+    throw new Error(`Unsupported type: ${input.type}`);
+  }
+  const startedTask = await startTask(input.type, input.slug, projectRoot);
+  const taskPath = join8(projectRoot, startedTask.workspacePath);
+  const specPath = join8(taskPath, "spec.md");
+  const planPath = join8(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");
+  return {
+    failed: [],
+    nextStatus: "PENDING_SPEC_APPROVAL",
+    path: startedTask.workspacePath,
+    planCreated: true,
+    specCreated: true,
+    succeeded: [{ note: "created minimal spec and plan", taskId: startedTask.workspaceId }],
+    taskId: startedTask.workspaceId
+  };
+}
+function buildFailureRows(taskId, failedRows, fallbackNote) {
+  if (failedRows.length === 0) {
+    if (fallbackNote === "") {
+      return [];
     }
-    return "file";
-  } catch {
-    return "missing";
+    return [{ note: fallbackNote, taskId }];
   }
+  return failedRows.map((row) => ({ note: row.note, taskId: row.taskId }));
 }
-async function ensureDirectory(targetPath) {
-  await mkdir(targetPath, { recursive: true });
+function buildSuccessRows(succeededRows) {
+  return succeededRows.map((row) => ({
+    note: `${row.note} (${String(row.steps)} steps)`,
+    taskId: row.taskId
+  }));
 }
-async function ensureReadableFile(targetPath) {
-  await access(targetPath, constants.R_OK);
+async function approveFastTrackTask(target, projectRoot) {
+  await approveSpecs(projectRoot, [toSpecApprovalTarget(target)], createSpecApprovedAt());
+  const planResult = await approvePlans(
+    projectRoot,
+    [toPlanApprovalTarget(target)],
+    createPlanApprovedAt()
+  );
+  if (planResult.succeeded.length === 0) {
+    return {
+      approved: false,
+      failed: buildFailureRows(target.id, planResult.failed, "plan approval failed"),
+      nextStatus: "SPEC_APPROVED",
+      succeeded: [{ note: "approved minimal spec", taskId: target.id }],
+      taskId: target.id
+    };
+  }
+  return {
+    approved: true,
+    failed: buildFailureRows(target.id, planResult.failed, ""),
+    nextStatus: "IN_PROGRESS",
+    succeeded: [
+      { note: "approved minimal spec", taskId: target.id },
+      ...buildSuccessRows(planResult.succeeded)
+    ],
+    taskId: target.id
+  };
 }
-async function copyFileIntoPlace(sourcePath, targetPath) {
-  await copyFile(sourcePath, targetPath);
+
+// src/commands/fast-track.ts
+function formatFailures(rows) {
+  return rows.map((row) => `- ${row.taskId}: ${row.note}`);
+}
+async function runFastTrackCommand(input, projectRoot) {
+  try {
+    const createdTask = await createFastTrackTask(input, projectRoot);
+    const lines = [
+      "fast-track task created",
+      `\uACBD\uB85C: ${createdTask.path}/`,
+      "minimal spec: created",
+      "minimal plan: created"
+    ];
+    if (!isInteractiveApprovalAvailable()) {
+      lines.push(
+        "\uC0C1\uD0DC: PENDING_SPEC_APPROVAL",
+        "\uB2E4\uC74C \uB2E8\uACC4: `sduck spec approve <slug>` \uD6C4 `sduck plan approve <slug>`\uB97C \uC2E4\uD589\uD558\uC138\uC694."
+      );
+      return {
+        exitCode: 0,
+        stderr: "",
+        stdout: lines.join("\n")
+      };
+    }
+    const shouldApprove = await confirm({
+      default: true,
+      message: "Approve the minimal spec and minimal plan now?"
+    });
+    if (!shouldApprove) {
+      lines.push(
+        "\uC0C1\uD0DC: PENDING_SPEC_APPROVAL",
+        "\uB2E4\uC74C \uB2E8\uACC4: `sduck spec approve <slug>` \uD6C4 `sduck plan approve <slug>`\uB97C \uC2E4\uD589\uD558\uC138\uC694."
+      );
+      return {
+        exitCode: 0,
+        stderr: "",
+        stdout: lines.join("\n")
+      };
+    }
+    const approvalResult = await approveFastTrackTask(
+      {
+        id: createdTask.taskId,
+        path: createdTask.path,
+        slug: input.slug,
+        status: "PENDING_SPEC_APPROVAL"
+      },
+      projectRoot
+    );
+    lines.push(`\uC0C1\uD0DC: ${approvalResult.nextStatus}`);
+    if (approvalResult.failed.length > 0) {
+      lines.push("\uC2B9\uC778 \uACB0\uACFC:", ...formatFailures(approvalResult.failed));
+    }
+    if (approvalResult.approved) {
+      lines.push("fast-track \uC2B9\uC778 \uC644\uB8CC \u2192 \uBC14\uB85C \uC791\uC5C5\uC744 \uC2DC\uC791\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+    } else {
+      lines.push("\uC77C\uBD80 \uC2B9\uC778 \uB2E8\uACC4\uAC00 \uC644\uB8CC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC77C\uBC18 \uC2B9\uC778 \uBA85\uB839\uC73C\uB85C \uC774\uC5B4\uC11C \uC9C4\uD589\uD558\uC138\uC694.");
+    }
+    return {
+      exitCode: approvalResult.failed.length > 0 ? 1 : 0,
+      stderr: "",
+      stdout: lines.join("\n")
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown fast-track failure.",
+      stdout: ""
+    };
+  }
 }
 
+// src/commands/init.ts
+import { checkbox } from "@inquirer/prompts";
+
 // src/core/agent-rules.ts
+import { readFile as readFile6 } from "fs/promises";
+import { dirname as dirname2, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var SDD_RULES_BEGIN = "<!-- sduck:begin -->";
 var SDD_RULES_END = "<!-- sduck:end -->";
 var SUPPORTED_AGENTS = [
@@ -51,17 +915,17 @@ var SUPPORTED_AGENTS = [
 ];
 var AGENT_RULE_TARGETS = [
   { agentId: "claude-code", outputPath: "CLAUDE.md", kind: "root-file" },
-  { agentId: "codex", outputPath: "AGENTS.md", kind: "root-file" },
-  { agentId: "opencode", outputPath: "AGENTS.md", kind: "root-file" },
+  { agentId: "codex", outputPath: "AGENT.md", kind: "root-file" },
+  { agentId: "opencode", outputPath: "AGENT.md", kind: "root-file" },
   { agentId: "gemini-cli", outputPath: "GEMINI.md", kind: "root-file" },
   {
     agentId: "cursor",
-    outputPath: join(".cursor", "rules", "sduck-core.mdc"),
+    outputPath: join9(".cursor", "rules", "sduck-core.mdc"),
     kind: "managed-file"
   },
   {
     agentId: "antigravity",
-    outputPath: join(".agents", "rules", "sduck-core.md"),
+    outputPath: join9(".agents", "rules", "sduck-core.md"),
     kind: "managed-file"
   }
 ];
@@ -120,10 +984,10 @@ function renderManagedBlock(lines) {
   return [SDD_RULES_BEGIN, ...lines, SDD_RULES_END].join("\n");
 }
 async function getAgentRulesAssetRoot() {
-  const currentDirectoryPath = dirname(fileURLToPath(import.meta.url));
+  const currentDirectoryPath = dirname2(fileURLToPath2(import.meta.url));
   const candidatePaths = [
-    join(currentDirectoryPath, "..", "..", "sduck-assets", "agent-rules"),
-    join(currentDirectoryPath, "..", "sduck-assets", "agent-rules")
+    join9(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets", "agent-rules"),
+    join9(currentDirectoryPath, "..", ".sduck", "sduck-assets", "agent-rules")
   ];
   for (const candidatePath of candidatePaths) {
     if (await getFsEntryKind(candidatePath) === "directory") {
@@ -133,7 +997,7 @@ async function getAgentRulesAssetRoot() {
   throw new Error("Unable to locate bundled sduck agent rule assets.");
 }
 async function readAssetFile(assetRoot, fileName) {
-  return await readFile(join(assetRoot, fileName), "utf8");
+  return await readFile6(join9(assetRoot, fileName), "utf8");
 }
 function buildRootFileLines(agentIds, agentSpecificContent) {
   const labels = SUPPORTED_AGENTS.filter((agent) => agentIds.includes(agent.id)).map(
@@ -165,111 +1029,67 @@ ${coreContent.trim()}
   for (const agentId of relatedAgents) {
     const templateFileName = AGENT_TEMPLATE_FILES[agentId];
     specificSections.push((await readAssetFile(assetRoot, templateFileName)).trim());
-  }
-  const lines = buildRootFileLines(relatedAgents, [...specificSections, coreContent.trim()]);
-  return `${renderManagedBlock(lines)}
-`;
-}
-function planAgentRuleActions(mode, targets, existingEntries, existingContents) {
-  return targets.map((target) => {
-    const currentKind = existingEntries.get(target.outputPath) ?? "missing";
-    if (currentKind === "missing") {
-      return { ...target, mergeMode: "create", currentKind };
-    }
-    if (currentKind !== "file") {
-      return { ...target, mergeMode: "overwrite", currentKind };
-    }
-    if (target.kind === "managed-file") {
-      return { ...target, mergeMode: mode === "force" ? "overwrite" : "keep", currentKind };
-    }
-    const content = existingContents.get(target.outputPath) ?? "";
-    if (mode === "safe") {
-      return { ...target, mergeMode: hasManagedBlock(content) ? "keep" : "prepend", currentKind };
-    }
-    return {
-      ...target,
-      mergeMode: hasManagedBlock(content) ? "replace-block" : "prepend",
-      currentKind
-    };
-  });
-}
-
-// src/core/init.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
-
-// src/core/assets.ts
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var SUPPORTED_TASK_TYPES = [
-  "build",
-  "feature",
-  "fix",
-  "refactor",
-  "chore"
-];
-var EVAL_ASSET_RELATIVE_PATHS = {
-  plan: join2("eval", "plan.yml"),
-  spec: join2("eval", "spec.yml")
-};
-var SPEC_TEMPLATE_RELATIVE_PATHS = {
-  build: join2("types", "build.md"),
-  feature: join2("types", "feature.md"),
-  fix: join2("types", "fix.md"),
-  refactor: join2("types", "refactor.md"),
-  chore: join2("types", "chore.md")
-};
-var INIT_ASSET_RELATIVE_PATHS = [
-  EVAL_ASSET_RELATIVE_PATHS.spec,
-  EVAL_ASSET_RELATIVE_PATHS.plan,
-  ...Object.values(SPEC_TEMPLATE_RELATIVE_PATHS)
-];
-async function getBundledAssetsRoot() {
-  const currentDirectoryPath = dirname2(fileURLToPath2(import.meta.url));
-  const candidatePaths = [
-    join2(currentDirectoryPath, "..", "..", "sduck-assets"),
-    join2(currentDirectoryPath, "..", "sduck-assets")
-  ];
-  for (const candidatePath of candidatePaths) {
-    if (await getFsEntryKind(candidatePath) === "directory") {
-      return candidatePath;
-    }
-  }
-  throw new Error("Unable to locate bundled sduck-assets directory.");
-}
-function isSupportedTaskType(value) {
-  return SUPPORTED_TASK_TYPES.includes(value);
+  }
+  const lines = buildRootFileLines(relatedAgents, [...specificSections, coreContent.trim()]);
+  return `${renderManagedBlock(lines)}
+`;
 }
-function resolveSpecTemplateRelativePath(type) {
-  return SPEC_TEMPLATE_RELATIVE_PATHS[type];
+function planAgentRuleActions(mode, targets, existingEntries, existingContents) {
+  return targets.map((target) => {
+    const currentKind = existingEntries.get(target.outputPath) ?? "missing";
+    if (currentKind === "missing") {
+      return { ...target, mergeMode: "create", currentKind };
+    }
+    if (currentKind !== "file") {
+      return { ...target, mergeMode: "overwrite", currentKind };
+    }
+    if (target.kind === "managed-file") {
+      return { ...target, mergeMode: mode === "force" ? "overwrite" : "keep", currentKind };
+    }
+    const content = existingContents.get(target.outputPath) ?? "";
+    if (mode === "safe") {
+      return { ...target, mergeMode: hasManagedBlock(content) ? "keep" : "prepend", currentKind };
+    }
+    return {
+      ...target,
+      mergeMode: hasManagedBlock(content) ? "replace-block" : "prepend",
+      currentKind
+    };
+  });
 }
 
 // src/core/init.ts
+import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname3, join as join10 } from "path";
 var ASSET_TEMPLATE_DEFINITIONS = [
   {
     key: "eval-spec",
-    relativePath: join3("sduck-assets", EVAL_ASSET_RELATIVE_PATHS.spec)
+    relativePath: getProjectRelativeSduckAssetPath(EVAL_ASSET_RELATIVE_PATHS.spec)
   },
   {
     key: "eval-plan",
-    relativePath: join3("sduck-assets", EVAL_ASSET_RELATIVE_PATHS.plan)
+    relativePath: getProjectRelativeSduckAssetPath(EVAL_ASSET_RELATIVE_PATHS.plan)
+  },
+  {
+    key: "eval-task",
+    relativePath: getProjectRelativeSduckAssetPath(EVAL_ASSET_RELATIVE_PATHS.task)
   },
   {
     key: "type-build",
-    relativePath: join3("sduck-assets", "types", "build.md")
+    relativePath: getProjectRelativeSduckAssetPath("types", "build.md")
   },
   {
     key: "type-feature",
-    relativePath: join3("sduck-assets", "types", "feature.md")
+    relativePath: getProjectRelativeSduckAssetPath("types", "feature.md")
   },
-  { key: "type-fix", relativePath: join3("sduck-assets", "types", "fix.md") },
+  { key: "type-fix", relativePath: getProjectRelativeSduckAssetPath("types", "fix.md") },
   {
     key: "type-refactor",
-    relativePath: join3("sduck-assets", "types", "refactor.md")
+    relativePath: getProjectRelativeSduckAssetPath("types", "refactor.md")
   },
   {
     key: "type-chore",
-    relativePath: join3("sduck-assets", "types", "chore.md")
+    relativePath: getProjectRelativeSduckAssetPath("types", "chore.md")
   }
 ];
 var ASSET_TEMPLATE_MAP = Object.fromEntries(
@@ -353,7 +1173,7 @@ async function collectExistingEntries(projectRoot) {
   for (const definition of ASSET_TEMPLATE_DEFINITIONS) {
     existingEntries.set(
       definition.relativePath,
-      await getFsEntryKind(join3(projectRoot, definition.relativePath))
+      await getFsEntryKind(join10(projectRoot, definition.relativePath))
     );
   }
   return existingEntries;
@@ -361,9 +1181,9 @@ async function collectExistingEntries(projectRoot) {
 async function collectExistingFileContents(projectRoot, targets) {
   const contents = /* @__PURE__ */ new Map();
   for (const target of targets) {
-    const targetPath = join3(projectRoot, target.outputPath);
+    const targetPath = join10(projectRoot, target.outputPath);
     if (await getFsEntryKind(targetPath) === "file") {
-      contents.set(target.outputPath, await readFile2(targetPath, "utf8"));
+      contents.set(target.outputPath, await readFile7(targetPath, "utf8"));
     }
   }
   return contents;
@@ -383,8 +1203,9 @@ async function initProject(options, projectRoot) {
   const resolvedOptions = resolveInitOptions(options);
   const { mode } = resolvedOptions;
   const assetSourceRoot = await getBundledAssetsRoot();
-  const assetsRoot = join3(projectRoot, "sduck-assets");
-  const workspaceRoot = join3(projectRoot, "sduck-workspace");
+  const sduckHomeRoot = getProjectSduckHomePath(projectRoot);
+  const assetsRoot = getProjectSduckAssetsPath(projectRoot);
+  const workspaceRoot = getProjectSduckWorkspacePath(projectRoot);
   const summary = {
     created: [],
     prepended: [],
@@ -394,12 +1215,18 @@ async function initProject(options, projectRoot) {
     errors: [],
     rows: []
   };
+  const sduckHomeStatus = await ensureRootDirectory(sduckHomeRoot, "asset-root-conflict");
+  summary[sduckHomeStatus].push(`${PROJECT_SDUCK_HOME_RELATIVE_PATH}/`);
+  summary.rows.push({ path: `${PROJECT_SDUCK_HOME_RELATIVE_PATH}/`, status: sduckHomeStatus });
   const assetsRootStatus = await ensureRootDirectory(assetsRoot, "asset-root-conflict");
-  summary[assetsRootStatus].push("sduck-assets/");
-  summary.rows.push({ path: "sduck-assets/", status: assetsRootStatus });
+  summary[assetsRootStatus].push(`${PROJECT_SDUCK_ASSETS_RELATIVE_PATH}/`);
+  summary.rows.push({ path: `${PROJECT_SDUCK_ASSETS_RELATIVE_PATH}/`, status: assetsRootStatus });
   const workspaceRootStatus = await ensureRootDirectory(workspaceRoot, "workspace-root-conflict");
-  summary[workspaceRootStatus].push("sduck-workspace/");
-  summary.rows.push({ path: "sduck-workspace/", status: workspaceRootStatus });
+  summary[workspaceRootStatus].push(`${PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH}/`);
+  summary.rows.push({
+    path: `${PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH}/`,
+    status: workspaceRootStatus
+  });
   const actions = planInitActions(mode, await collectExistingEntries(projectRoot));
   const actionSummary = summarizeInitActions(actions);
   summary.created.push(...actionSummary.created);
@@ -419,13 +1246,10 @@ async function initProject(options, projectRoot) {
       continue;
     }
     const definition = ASSET_TEMPLATE_MAP[action.key];
-    const sourcePath = join3(
-      assetSourceRoot,
-      definition.relativePath.replace(/^sduck-assets[\\/]/, "")
-    );
-    const targetPath = join3(projectRoot, definition.relativePath);
+    const sourcePath = join10(assetSourceRoot, toBundledAssetRelativePath(definition.relativePath));
+    const targetPath = join10(projectRoot, definition.relativePath);
     await ensureReadableFile(sourcePath);
-    await mkdir2(dirname3(targetPath), { recursive: true });
+    await mkdir3(dirname3(targetPath), { recursive: true });
     await copyFileIntoPlace(sourcePath, targetPath);
   }
   const agentTargets = listAgentRuleTargets(resolvedOptions.agents);
@@ -433,7 +1257,7 @@ async function initProject(options, projectRoot) {
   for (const target of agentTargets) {
     agentEntryKinds.set(
       target.outputPath,
-      await getFsEntryKind(join3(projectRoot, target.outputPath))
+      await getFsEntryKind(join10(projectRoot, target.outputPath))
     );
   }
   const existingContents = await collectExistingFileContents(projectRoot, agentTargets);
@@ -454,11 +1278,11 @@ async function initProject(options, projectRoot) {
 }
 async function applyAgentRuleActions(projectRoot, actions, existingContents, summary, selectedAgents) {
   for (const action of actions) {
-    const targetPath = join3(projectRoot, action.outputPath);
+    const targetPath = join10(projectRoot, action.outputPath);
     const content = await renderAgentRuleContent(action, selectedAgents);
     if (action.mergeMode === "create") {
-      await mkdir2(dirname3(targetPath), { recursive: true });
-      await writeFile(targetPath, content, "utf8");
+      await mkdir3(dirname3(targetPath), { recursive: true });
+      await writeFile6(targetPath, content, "utf8");
       summary.created.push(action.outputPath);
       summary.rows.push({ path: action.outputPath, status: "created" });
       continue;
@@ -469,290 +1293,116 @@ async function applyAgentRuleActions(projectRoot, actions, existingContents, sum
       summary.warnings.push(`Kept existing rule file: ${action.outputPath}`);
       continue;
     }
-    await mkdir2(dirname3(targetPath), { recursive: true });
+    await mkdir3(dirname3(targetPath), { recursive: true });
     if (action.mergeMode === "prepend") {
       const currentContent = existingContents.get(action.outputPath) ?? "";
-      await writeFile(targetPath, prependManagedBlock(currentContent, content.trimEnd()), "utf8");
+      await writeFile6(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 writeFile(targetPath, replaceManagedBlock(currentContent, content.trimEnd()), "utf8");
+      await writeFile6(targetPath, replaceManagedBlock(currentContent, content.trimEnd()), "utf8");
       summary.overwritten.push(action.outputPath);
       summary.rows.push({ path: action.outputPath, status: "overwritten" });
       continue;
     }
-    await writeFile(targetPath, content, "utf8");
+    await writeFile6(targetPath, content, "utf8");
     summary.overwritten.push(action.outputPath);
     summary.rows.push({ path: action.outputPath, status: "overwritten" });
   }
   if (summary.kept.some((path) => path.endsWith(".md") || path.endsWith(".mdc"))) {
-    summary.warnings.push(
-      "Run `sduck init --force` to refresh managed rule content for selected agents."
-    );
-  }
-}
-
-// src/commands/init.ts
-function padCell(value, width) {
-  return value.padEnd(width, " ");
-}
-function buildSummaryTable(rows) {
-  const statusWidth = Math.max("Status".length, ...rows.map((row) => row.status.length));
-  const pathWidth = Math.max("Path".length, ...rows.map((row) => row.path.length));
-  const border = `+-${"-".repeat(statusWidth)}-+-${"-".repeat(pathWidth)}-+`;
-  const header = `| ${padCell("Status", statusWidth)} | ${padCell("Path", pathWidth)} |`;
-  const body = rows.map(
-    (row) => `| ${padCell(row.status, statusWidth)} | ${padCell(row.path, pathWidth)} |`
-  );
-  return [border, header, border, ...body, border].join("\n");
-}
-function formatResult(result) {
-  const lines = [
-    result.didChange ? "sduck init completed." : "sduck init completed with no file changes."
-  ];
-  if (result.agents.length > 0) {
-    lines.push(`Selected agents: ${result.agents.join(", ")}`);
-  }
-  lines.push("", buildSummaryTable(result.summary.rows));
-  if (result.summary.warnings.length > 0) {
-    lines.push("", "Warnings:");
-    lines.push(...result.summary.warnings.map((warning) => `- ${warning}`));
-  }
-  return lines.join("\n");
-}
-async function resolveSelectedAgents(options) {
-  const parsedAgents = parseAgentsOption(options.agents);
-  if (parsedAgents.length > 0 || !process.stdin.isTTY || !process.stdout.isTTY) {
-    return parsedAgents;
-  }
-  return await checkbox({
-    message: "Select AI agents to generate repository rule files for",
-    choices: SUPPORTED_AGENTS.map((agent) => ({
-      name: agent.label,
-      value: agent.id
-    }))
-  });
-}
-async function runInitCommand(options, projectRoot) {
-  try {
-    const resolvedOptions = {
-      force: options.force,
-      agents: await resolveSelectedAgents(options)
-    };
-    const result = await initProject(resolvedOptions, projectRoot);
-    return {
-      exitCode: 0,
-      stderr: "",
-      stdout: formatResult(result)
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown init failure.";
-    return {
-      exitCode: 1,
-      stderr: message,
-      stdout: ""
-    };
-  }
-}
-
-// src/commands/plan-approve.ts
-import { checkbox as checkbox2 } from "@inquirer/prompts";
-
-// src/core/plan-approve.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join5 } from "path";
-
-// src/core/workspace.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["IN_PROGRESS", "PENDING_SPEC_APPROVAL", "PENDING_PLAN_APPROVAL"]);
-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 parsedMeta = {};
-  if (createdAtMatch?.[1] !== void 0) {
-    parsedMeta.createdAt = createdAtMatch[1].trim();
-  }
-  if (idMatch?.[1] !== void 0) {
-    parsedMeta.id = idMatch[1].trim();
-  }
-  if (slugMatch?.[1] !== void 0) {
-    parsedMeta.slug = slugMatch[1].trim();
-  }
-  if (statusMatch?.[1] !== void 0) {
-    parsedMeta.status = statusMatch[1].trim();
-  }
-  return parsedMeta;
-}
-function sortTasksByRecency(tasks) {
-  return [...tasks].sort((left, right) => {
-    const leftValue = left.createdAt ?? "";
-    const rightValue = right.createdAt ?? "";
-    return rightValue.localeCompare(leftValue);
-  });
-}
-async function listWorkspaceTasks(projectRoot) {
-  const workspaceRoot = join4(projectRoot, "sduck-workspace");
-  if (await getFsEntryKind(workspaceRoot) !== "directory") {
-    return [];
-  }
-  const { readdir } = await import("fs/promises");
-  const entries = await readdir(workspaceRoot, { withFileTypes: true });
-  const tasks = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const relativePath = join4("sduck-workspace", entry.name);
-    const metaPath = join4(projectRoot, relativePath, "meta.yml");
-    if (await getFsEntryKind(metaPath) !== "file") {
-      continue;
-    }
-    const parsedMeta = parseMetaText(await readFile3(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);
-    }
-  }
-  return sortTasksByRecency(tasks);
-}
-async function findActiveTask(projectRoot) {
-  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
-      };
-    }
-  }
-  return null;
-}
-
-// 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/plan-approve.ts
-function filterPlanApprovalCandidates(tasks) {
-  return tasks.filter((task) => task.status === "SPEC_APPROVED");
-}
-function resolvePlanApprovalCandidates(tasks, target) {
-  const candidates = filterPlanApprovalCandidates(tasks);
-  if (target === void 0 || target.trim() === "") {
-    return candidates;
-  }
-  const trimmedTarget = target.trim();
-  return candidates.filter(
-    (task) => task.id === trimmedTarget || task.slug === trimmedTarget || task.id.endsWith(trimmedTarget)
-  );
-}
-function countPlanSteps(planContent) {
-  const matches = planContent.match(/^## Step \d+\. .+$/gm);
-  return matches?.length ?? 0;
-}
-function updatePlanApprovalBlock(metaContent, approvedAt, totalSteps) {
-  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: IN_PROGRESS");
-  const withPlan = withStatus.replace(
-    /plan:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
-    `plan:
-  approved: true
-  approved_at: ${approvedAt}`
-  );
-  return withPlan.replace(
-    /steps:\n {2}total:\s+null\n {2}completed:\s+\[\]/m,
-    `steps:
-  total: ${String(totalSteps)}
-  completed: []`
-  );
-}
-async function approvePlans(projectRoot, tasks, approvedAt) {
-  const succeeded = [];
-  const failed = [];
-  for (const task of tasks) {
-    if (task.status !== "SPEC_APPROVED") {
-      failed.push({
-        note: `task is not awaiting plan approval (${task.status})`,
-        taskId: task.id
-      });
-      continue;
-    }
-    const metaPath = join5(projectRoot, task.path, "meta.yml");
-    const planPath = join5(projectRoot, task.path, "plan.md");
-    if (await getFsEntryKind(metaPath) !== "file") {
-      failed.push({ note: "missing meta.yml", taskId: task.id });
-      continue;
-    }
-    if (await getFsEntryKind(planPath) !== "file") {
-      failed.push({ note: "missing plan.md", taskId: task.id });
-      continue;
-    }
-    const planContent = await readFile4(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"),
-      approvedAt,
-      totalSteps
+    summary.warnings.push(
+      "Run `sduck init --force` to refresh managed rule content for selected agents."
     );
-    await writeFile2(metaPath, updatedMeta, "utf8");
-    succeeded.push({ note: "moved to IN_PROGRESS", steps: totalSteps, taskId: task.id });
   }
+}
+
+// src/commands/init.ts
+var AGENT_PROMPT_MESSAGE = "Select AI agents to generate repository rule files for";
+var AGENT_PROMPT_INSTRUCTIONS = "Use space to toggle agents, arrow keys to move, and enter to submit.";
+var AGENT_PROMPT_REQUIRED_MESSAGE = "Select at least one agent. Use space to toggle and enter to submit.";
+function padCell2(value, width) {
+  return value.padEnd(width, " ");
+}
+function buildSummaryTable(rows) {
+  const statusWidth = Math.max("Status".length, ...rows.map((row) => row.status.length));
+  const pathWidth = Math.max("Path".length, ...rows.map((row) => row.path.length));
+  const border = `+-${"-".repeat(statusWidth)}-+-${"-".repeat(pathWidth)}-+`;
+  const header = `| ${padCell2("Status", statusWidth)} | ${padCell2("Path", pathWidth)} |`;
+  const body = rows.map(
+    (row) => `| ${padCell2(row.status, statusWidth)} | ${padCell2(row.path, pathWidth)} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
+}
+function formatResult(result) {
+  const lines = [
+    result.didChange ? "sduck init completed." : "sduck init completed with no file changes."
+  ];
+  if (result.agents.length > 0) {
+    lines.push(`Selected agents: ${result.agents.join(", ")}`);
+  }
+  lines.push("", buildSummaryTable(result.summary.rows));
+  if (result.summary.warnings.length > 0) {
+    lines.push("", "Warnings:");
+    lines.push(...result.summary.warnings.map((warning) => `- ${warning}`));
+  }
+  return lines.join("\n");
+}
+function normalizeSelectedAgents(agentIds) {
+  const selectedAgentSet = new Set(agentIds);
+  return SUPPORTED_AGENTS.map((agent) => agent.id).filter(
+    (agentId) => selectedAgentSet.has(agentId)
+  );
+}
+function createAgentCheckboxConfig() {
   return {
-    approvedAt,
-    failed,
-    nextStatus: "IN_PROGRESS",
-    succeeded
+    message: AGENT_PROMPT_MESSAGE,
+    instructions: AGENT_PROMPT_INSTRUCTIONS,
+    required: true,
+    validate: (choices) => choices.length > 0 || AGENT_PROMPT_REQUIRED_MESSAGE,
+    choices: SUPPORTED_AGENTS.map((agent) => ({
+      name: agent.label,
+      value: agent.id
+    }))
   };
 }
-async function loadPlanApprovalCandidates(projectRoot, input) {
-  const tasks = await listWorkspaceTasks(projectRoot);
-  return resolvePlanApprovalCandidates(tasks, input.target);
+async function resolveSelectedAgents(options) {
+  const parsedAgents = parseAgentsOption(options.agents);
+  if (parsedAgents.length > 0 || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return normalizeSelectedAgents(parsedAgents);
+  }
+  return normalizeSelectedAgents(await checkbox(createAgentCheckboxConfig()));
 }
-function createPlanApprovedAt(date = /* @__PURE__ */ new Date()) {
-  return formatUtcTimestamp(date);
+async function runInitCommand(options, projectRoot) {
+  try {
+    const resolvedOptions = {
+      force: options.force,
+      agents: await resolveSelectedAgents(options)
+    };
+    const result = await initProject(resolvedOptions, projectRoot);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: formatResult(result)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown init failure.";
+    return {
+      exitCode: 1,
+      stderr: message,
+      stdout: ""
+    };
+  }
 }
 
 // src/commands/plan-approve.ts
-function padCell2(value, width) {
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+function padCell3(value, width) {
   return value.padEnd(width, " ");
 }
-function buildResultTable(result) {
+function buildResultTable2(result) {
   const rows = [
     ...result.succeeded.map((row) => ({
       note: row.note,
@@ -772,17 +1422,17 @@ function buildResultTable(result) {
   const stepsWidth = Math.max("Steps".length, ...rows.map((row) => row.steps.length));
   const noteWidth = Math.max("Note".length, ...rows.map((row) => row.note.length));
   const border = `+-${"-".repeat(resultWidth)}-+-${"-".repeat(taskWidth)}-+-${"-".repeat(stepsWidth)}-+-${"-".repeat(noteWidth)}-+`;
-  const header = `| ${padCell2("Result", resultWidth)} | ${padCell2("Task", taskWidth)} | ${padCell2("Steps", stepsWidth)} | ${padCell2("Note", noteWidth)} |`;
+  const header = `| ${padCell3("Result", resultWidth)} | ${padCell3("Task", taskWidth)} | ${padCell3("Steps", stepsWidth)} | ${padCell3("Note", noteWidth)} |`;
   const body = rows.map(
-    (row) => `| ${padCell2(row.result, resultWidth)} | ${padCell2(row.task, taskWidth)} | ${padCell2(row.steps, stepsWidth)} | ${padCell2(row.note, noteWidth)} |`
+    (row) => `| ${padCell3(row.result, resultWidth)} | ${padCell3(row.task, taskWidth)} | ${padCell3(row.steps, stepsWidth)} | ${padCell3(row.note, noteWidth)} |`
   );
   return [border, header, border, ...body, border].join("\n");
 }
 function formatTaskLabel(task) {
   return `${task.id} (${task.status})`;
 }
-function formatSuccess(result) {
-  const lines = [buildResultTable(result)];
+function formatSuccess2(result) {
+  const lines = [buildResultTable2(result)];
   if (result.succeeded.length > 0) {
     lines.push("", "\uC0C1\uD0DC: IN_PROGRESS \u2192 \uC791\uC5C5\uC744 \uC2DC\uC791\uD569\uB2C8\uB2E4.");
   }
@@ -817,14 +1467,14 @@ async function runPlanApproveCommand(input, projectRoot) {
     if (result.succeeded.length === 0) {
       return {
         exitCode: 1,
-        stderr: buildResultTable(result),
+        stderr: buildResultTable2(result),
         stdout: ""
       };
     }
     return {
       exitCode: result.failed.length > 0 ? 1 : 0,
       stderr: result.failed.length > 0 ? "" : "",
-      stdout: formatSuccess(result)
+      stdout: formatSuccess2(result)
     };
   } catch (error) {
     return {
@@ -837,72 +1487,10 @@ async function runPlanApproveCommand(input, projectRoot) {
 
 // src/commands/spec-approve.ts
 import { checkbox as checkbox3 } from "@inquirer/prompts";
-
-// src/core/spec-approve.ts
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import { join as join6 } from "path";
-function filterApprovalCandidates(tasks) {
-  return tasks.filter((task) => task.status === "PENDING_SPEC_APPROVAL");
-}
-function resolveTargetCandidates(tasks, target) {
-  const candidates = filterApprovalCandidates(tasks);
-  if (target === void 0 || target.trim() === "") {
-    return candidates;
-  }
-  const trimmedTarget = target.trim();
-  return candidates.filter(
-    (task) => task.id === trimmedTarget || task.slug === trimmedTarget || task.id.endsWith(trimmedTarget)
-  );
-}
-function validateSpecApprovalTargets(tasks) {
-  if (tasks.length === 0) {
-    throw new Error("No approvable spec tasks found.");
-  }
-  const invalidTask = tasks.find((task) => task.status !== "PENDING_SPEC_APPROVAL");
-  if (invalidTask !== void 0) {
-    throw new Error(
-      `Task ${invalidTask.id} is not awaiting spec approval (${invalidTask.status}).`
-    );
-  }
-}
-function updateSpecApprovalBlock(metaContent, approvedAt) {
-  const withStatus = metaContent.replace(/^status:\s+.+$/m, "status: SPEC_APPROVED");
-  return withStatus.replace(
-    /spec:\n {2}approved:\s+false\n {2}approved_at:\s+null/m,
-    `spec:
-  approved: true
-  approved_at: ${approvedAt}`
-  );
-}
-async function approveSpecs(projectRoot, tasks, approvedAt) {
-  validateSpecApprovalTargets(tasks);
-  for (const task of tasks) {
-    const metaPath = join6(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");
-  }
-  return {
-    approvedAt,
-    approvedTaskIds: tasks.map((task) => task.id),
-    nextStatus: "SPEC_APPROVED"
-  };
-}
-async function loadSpecApprovalCandidates(projectRoot, input) {
-  const tasks = await listWorkspaceTasks(projectRoot);
-  return resolveTargetCandidates(tasks, input.target);
-}
-function createSpecApprovedAt(date = /* @__PURE__ */ new Date()) {
-  return formatUtcTimestamp(date);
-}
-
-// src/commands/spec-approve.ts
 function formatTaskLabel2(task) {
   return `${task.id} (${task.status})`;
 }
-function formatSuccess2(result, tasks) {
+function formatSuccess3(result, tasks) {
   const lines = ["\uC2A4\uD399 \uC2B9\uC778\uB428"];
   for (const task of tasks) {
     lines.push(`- ${task.path} -> ${result.nextStatus}`);
@@ -943,7 +1531,7 @@ async function runSpecApproveCommand(input, projectRoot) {
     return {
       exitCode: 0,
       stderr: "",
-      stdout: formatSuccess2(result, selectedTasks)
+      stdout: formatSuccess3(result, selectedTasks)
     };
   } catch (error) {
     return {
@@ -954,104 +1542,6 @@ async function runSpecApproveCommand(input, projectRoot) {
   }
 }
 
-// src/core/start.ts
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { join as join7 } from "path";
-function normalizeSlug(input) {
-  return input.trim().toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function validateSlug(slug) {
-  if (slug === "") {
-    throw new Error("Invalid slug: slug cannot be empty after normalization.");
-  }
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
-    throw new Error("Invalid slug: use lowercase kebab-case only.");
-  }
-}
-function createWorkspaceId(date, type, slug) {
-  const year = String(date.getUTCFullYear());
-  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date.getUTCDate()).padStart(2, "0");
-  const hour = String(date.getUTCHours()).padStart(2, "0");
-  const minute = String(date.getUTCMinutes()).padStart(2, "0");
-  return `${year}${month}${day}-${hour}${minute}-${type}-${slug}`;
-}
-function renderInitialMeta(input) {
-  return [
-    `id: ${input.id}`,
-    `type: ${input.type}`,
-    `slug: ${input.slug}`,
-    `created_at: ${input.createdAt}`,
-    "",
-    "status: PENDING_SPEC_APPROVAL",
-    "",
-    "spec:",
-    "  approved: false",
-    "  approved_at: null",
-    "",
-    "plan:",
-    "  approved: false",
-    "  approved_at: null",
-    "",
-    "steps:",
-    "  total: null",
-    "  completed: []",
-    "",
-    "completed_at: null",
-    ""
-  ].join("\n");
-}
-async function resolveSpecTemplatePath(type) {
-  const assetsRoot = await getBundledAssetsRoot();
-  return join7(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()) {
-  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 workspacePath = join7("sduck-workspace", workspaceId);
-  const absoluteWorkspacePath = join7(projectRoot, workspacePath);
-  if (await getFsEntryKind(absoluteWorkspacePath) !== "missing") {
-    throw new Error(`Workspace already exists: ${workspacePath}`);
-  }
-  const workspaceRoot = join7(projectRoot, "sduck-workspace");
-  await mkdir3(workspaceRoot, { recursive: true });
-  await mkdir3(absoluteWorkspacePath, { recursive: false });
-  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 specContent = applyTemplateDefaults(specTemplate, rawType, slug, currentDate);
-  const metaContent = renderInitialMeta({
-    createdAt: formatUtcTimestamp(currentDate),
-    id: workspaceId,
-    slug,
-    type: rawType
-  });
-  await writeFile4(join7(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
-  await writeFile4(join7(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
-  await writeFile4(join7(absoluteWorkspacePath, "plan.md"), "", "utf8");
-  return {
-    workspaceId,
-    workspacePath,
-    status: "PENDING_SPEC_APPROVAL"
-  };
-}
-
 // src/commands/start.ts
 async function runStartCommand(type, slug, projectRoot) {
   try {
@@ -1074,8 +1564,70 @@ async function runStartCommand(type, slug, projectRoot) {
   }
 }
 
+// package.json
+var package_default = {
+  name: "@sduck/sduck-cli",
+  version: "0.1.2",
+  description: "Spec-Driven Development CLI bootstrap",
+  type: "module",
+  bin: {
+    sduck: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "sduck-assets"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  scripts: {
+    dev: "tsx src/cli.ts",
+    build: "tsup src/cli.ts --config tsup.config.ts",
+    lint: "eslint . --max-warnings=0",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    typecheck: "tsc --project tsconfig.json --noEmit",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    test: "npm run test:unit && npm run test:e2e",
+    prepare: "husky"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs,ts,mts,cts}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  dependencies: {
+    "@inquirer/prompts": "^7.8.6",
+    commander: "^14.0.1",
+    "js-yaml": "^4.1.0"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.23.0",
+    "@types/node": "^22.13.14",
+    eslint: "^9.23.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-import-resolver-typescript": "^4.3.5",
+    "eslint-plugin-n": "^17.16.2",
+    husky: "^9.1.7",
+    "lint-staged": "^15.5.0",
+    prettier: "^3.5.3",
+    tsup: "^8.4.0",
+    tsx: "^4.19.3",
+    typescript: "^5.8.2",
+    "typescript-eslint": "^8.28.0",
+    vitest: "^3.0.8"
+  }
+};
+
 // src/core/command-metadata.ts
 var CLI_NAME = "sduck";
+var CLI_VERSION = package_default.version;
 var CLI_DESCRIPTION = "Spec-Driven Development workflow bootstrap CLI";
 var PLACEHOLDER_MESSAGE = "Core workflow commands are planned but not implemented in this bootstrap yet.";
 function normalizeCommandName(input) {
@@ -1084,8 +1636,8 @@ function normalizeCommandName(input) {
 
 // src/cli.ts
 var program = new Command();
-program.name(CLI_NAME).description(CLI_DESCRIPTION).version("0.1.0");
-program.command("init").description("Initialize the current repository for the SDD workflow").option("--force", "Regenerate the bundled assets in sduck-assets").option(
+program.name(CLI_NAME).description(CLI_DESCRIPTION).version(CLI_VERSION);
+program.command("init").description("Initialize the current repository for the SDD workflow").option("--force", "Regenerate the bundled assets in .sduck/sduck-assets").option(
   "--agents <agents>",
   "Comma-separated agents (claude-code,codex,opencode,gemini-cli,cursor,antigravity)"
 ).action(async (options) => {
@@ -1116,6 +1668,18 @@ 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());
+  if (result.stdout !== "") {
+    console.log(result.stdout);
+  }
+  if (result.stderr !== "") {
+    console.error(result.stderr);
+  }
+  if (result.exitCode !== 0) {
+    process.exitCode = result.exitCode;
+  }
+});
 program.command("spec").description("Manage spec workflow state").command("approve [target]").description("Approve a task spec and move it to plan writing").action(async (target) => {
   const input = target === void 0 ? {} : { target };
   const result = await runSpecApproveCommand(input, process.cwd());
@@ -1142,6 +1706,19 @@ program.command("plan").description("Manage plan workflow state").command("appro
     process.exitCode = result.exitCode;
   }
 });
+program.command("done [target]").description("Complete an in-progress task after validation").action(async (target) => {
+  const input = target === void 0 ? {} : { target };
+  const result = await runDoneCommand(input, 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);
 });