@sduck/sduck-cli 0.1.3 → 0.1.5

package/dist/cli.js

@@ -3,8 +3,8 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/core/done.ts
-import { readFile as readFile2, writeFile } from "fs/promises";
+// src/core/archive.ts
+import { readFile as readFile2, rename } from "fs/promises";
 import { join as join3 } from "path";
 
 // src/core/fs.ts
@@ -39,9 +39,11 @@ 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 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);
+var PROJECT_SDUCK_ARCHIVE_RELATIVE_PATH = join(SDUCK_HOME_DIR, SDUCK_ARCHIVE_DIR);
 function getProjectSduckHomePath(projectRoot) {
   return join(projectRoot, PROJECT_SDUCK_HOME_RELATIVE_PATH);
 }
@@ -51,6 +53,9 @@ function getProjectSduckAssetsPath(projectRoot) {
 function getProjectSduckWorkspacePath(projectRoot) {
   return join(projectRoot, PROJECT_SDUCK_WORKSPACE_RELATIVE_PATH);
 }
+function getProjectSduckArchivePath(projectRoot) {
+  return join(projectRoot, PROJECT_SDUCK_ARCHIVE_RELATIVE_PATH);
+}
 function getProjectRelativeSduckAssetPath(...segments) {
   return join(PROJECT_SDUCK_ASSETS_RELATIVE_PATH, ...segments);
 }
@@ -141,6 +146,128 @@ async function findActiveTask(projectRoot) {
   return null;
 }
 
+// src/core/archive.ts
+function extractCompletedAt(metaContent) {
+  const match = /^completed_at:\s+(.+)$/m.exec(metaContent);
+  const value = match?.[1]?.trim();
+  if (value === void 0 || value === "null") {
+    return null;
+  }
+  return value;
+}
+function deriveArchiveMonth(completedAt) {
+  return completedAt.slice(0, 7);
+}
+function filterArchiveCandidates(tasks) {
+  return tasks.filter((task) => task.status === "DONE");
+}
+async function isAlreadyArchived(archivePath, taskDirName) {
+  const targetPath = join3(archivePath, taskDirName);
+  return await getFsEntryKind(targetPath) === "directory";
+}
+async function loadArchiveTargets(projectRoot, input) {
+  const tasks = await listWorkspaceTasks(projectRoot);
+  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 completedAt = extractCompletedAt(metaContent);
+    if (completedAt === null) {
+      continue;
+    }
+    targets.push({
+      completedAt,
+      id: task.id,
+      month: deriveArchiveMonth(completedAt),
+      path: task.path,
+      slug: task.slug
+    });
+  }
+  targets.sort((a, b) => a.completedAt.localeCompare(b.completedAt));
+  const keep = input.keep ?? 0;
+  if (keep > 0 && targets.length > keep) {
+    return targets.slice(0, targets.length - keep);
+  }
+  return targets;
+}
+async function runArchiveWorkflow(projectRoot, targets) {
+  const archiveRoot = getProjectSduckArchivePath(projectRoot);
+  const archived = [];
+  const skipped = [];
+  for (const target of targets) {
+    const monthDir = join3(archiveRoot, target.month);
+    await ensureDirectory(monthDir);
+    const segments = target.path.split("/");
+    const taskDirName = segments.at(-1) ?? target.id;
+    if (await isAlreadyArchived(monthDir, taskDirName)) {
+      skipped.push({ reason: "already archived", taskId: target.id });
+      continue;
+    }
+    const sourcePath = join3(projectRoot, target.path);
+    const destPath = join3(monthDir, taskDirName);
+    await rename(sourcePath, destPath);
+    archived.push({ month: target.month, taskId: target.id });
+  }
+  return { archived, skipped };
+}
+
+// src/commands/archive.ts
+function padCell(value, width) {
+  return value.padEnd(width, " ");
+}
+function buildResultTable(result) {
+  const rows = [
+    ...result.archived.map((row) => ({
+      month: row.month,
+      result: "archived",
+      task: row.taskId
+    })),
+    ...result.skipped.map((row) => ({
+      month: "",
+      result: "skipped",
+      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 monthWidth = Math.max("Month".length, ...rows.map((row) => row.month.length));
+  const border = `+-${"-".repeat(resultWidth)}-+-${"-".repeat(taskWidth)}-+-${"-".repeat(monthWidth)}-+`;
+  const header = `| ${padCell("Result", resultWidth)} | ${padCell("Task", taskWidth)} | ${padCell("Month", monthWidth)} |`;
+  const body = rows.map(
+    (row) => `| ${padCell(row.result, resultWidth)} | ${padCell(row.task, taskWidth)} | ${padCell(row.month, monthWidth)} |`
+  );
+  return [border, header, border, ...body, border].join("\n");
+}
+async function runArchiveCommand(input, projectRoot) {
+  try {
+    const targets = await loadArchiveTargets(projectRoot, input);
+    if (targets.length === 0) {
+      return {
+        exitCode: 0,
+        stderr: "",
+        stdout: "\uC544\uCE74\uC774\uBE0C \uB300\uC0C1\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+      };
+    }
+    const result = await runArchiveWorkflow(projectRoot, targets);
+    return {
+      exitCode: 0,
+      stderr: "",
+      stdout: buildResultTable(result)
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : "Unknown archive failure.",
+      stdout: ""
+    };
+  }
+}
+
+// src/core/done.ts
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { join as join4 } from "path";
+
 // src/utils/utc-date.ts
 function pad2(value) {
   return String(value).padStart(2, "0");
@@ -243,11 +370,11 @@ function validateDoneTarget(task) {
   }
 }
 async function loadTaskEvalCriteria(projectRoot) {
-  const taskEvalPath = join3(projectRoot, TASK_EVAL_ASSET_PATH);
+  const taskEvalPath = join4(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 taskEvalContent = await readFile3(taskEvalPath, "utf8");
   const labels = extractTaskEvalCriteriaLabels(taskEvalContent);
   if (labels.length === 0) {
     throw new Error(`Task evaluation asset has no criteria labels: ${TASK_EVAL_ASSET_PATH}.`);
@@ -256,17 +383,17 @@ async function loadTaskEvalCriteria(projectRoot) {
 }
 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");
+  const metaPath = join4(projectRoot, task.path, "meta.yml");
+  const specPath = join4(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");
+  const metaContent = await readFile3(metaPath, "utf8");
   validateDoneMetaContent(metaContent);
-  const specContent = await readFile2(specPath, "utf8");
+  const specContent = await readFile3(specPath, "utf8");
   const uncheckedItems = extractUncheckedChecklistItems(specContent);
   if (uncheckedItems.length > 0) {
     throw new Error(`Spec checklist is incomplete: ${uncheckedItems.join("; ")}`);
@@ -332,10 +459,10 @@ function createTaskCompletedAt(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/commands/done.ts
-function padCell(value, width) {
+function padCell2(value, width) {
   return value.padEnd(width, " ");
 }
-function buildResultTable(result) {
+function buildResultTable2(result) {
   const rows = [
     ...result.succeeded.map((row) => ({
       note: row.note,
@@ -352,9 +479,9 @@ function buildResultTable(result) {
   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 header = `| ${padCell2("Result", resultWidth)} | ${padCell2("Task", taskWidth)} | ${padCell2("Note", noteWidth)} |`;
   const body = rows.map(
-    (row) => `| ${padCell(row.result, resultWidth)} | ${padCell(row.task, taskWidth)} | ${padCell(row.note, noteWidth)} |`
+    (row) => `| ${padCell2(row.result, resultWidth)} | ${padCell2(row.task, taskWidth)} | ${padCell2(row.note, noteWidth)} |`
   );
   return [border, header, border, ...body, border].join("\n");
 }
@@ -372,7 +499,7 @@ function formatFailureDetails(failed) {
   return lines;
 }
 function formatSuccess(result) {
-  const lines = [buildResultTable(result)];
+  const lines = [buildResultTable2(result)];
   if (result.succeeded.length > 0) {
     const criteriaLabels = result.succeeded[0]?.taskEvalCriteria ?? [];
     lines.push("", "\uC0C1\uD0DC: DONE");
@@ -413,10 +540,10 @@ import { confirm } from "@inquirer/prompts";
 
 // src/core/fast-track.ts
 import { writeFile as writeFile5 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/core/assets.ts
-import { dirname, join as join4 } from "path";
+import { dirname, join as join5 } from "path";
 import { fileURLToPath } from "url";
 var SUPPORTED_TASK_TYPES = [
   "build",
@@ -426,16 +553,16 @@ var SUPPORTED_TASK_TYPES = [
   "chore"
 ];
 var EVAL_ASSET_RELATIVE_PATHS = {
-  task: join4("eval", "task.yml"),
-  plan: join4("eval", "plan.yml"),
-  spec: join4("eval", "spec.yml")
+  task: join5("eval", "task.yml"),
+  plan: join5("eval", "plan.yml"),
+  spec: join5("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")
+  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")
 };
 var INIT_ASSET_RELATIVE_PATHS = [
   EVAL_ASSET_RELATIVE_PATHS.spec,
@@ -446,8 +573,8 @@ var INIT_ASSET_RELATIVE_PATHS = [
 async function getBundledAssetsRoot() {
   const currentDirectoryPath = dirname(fileURLToPath(import.meta.url));
   const candidatePaths = [
-    join4(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets"),
-    join4(currentDirectoryPath, "..", ".sduck", "sduck-assets")
+    join5(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets"),
+    join5(currentDirectoryPath, "..", ".sduck", "sduck-assets")
   ];
   for (const candidatePath of candidatePaths) {
     if (await getFsEntryKind(candidatePath) === "directory") {
@@ -464,8 +591,8 @@ function resolveSpecTemplateRelativePath(type) {
 }
 
 // src/core/plan-approve.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join5 } from "path";
+import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
 function filterPlanApprovalCandidates(tasks) {
   return tasks.filter((task) => task.status === "SPEC_APPROVED");
 }
@@ -507,8 +634,8 @@ async function approvePlans(projectRoot, tasks, approvedAt) {
       });
       continue;
     }
-    const metaPath = join5(projectRoot, task.path, "meta.yml");
-    const planPath = join5(projectRoot, task.path, "plan.md");
+    const metaPath = join6(projectRoot, task.path, "meta.yml");
+    const planPath = join6(projectRoot, task.path, "plan.md");
     if (await getFsEntryKind(metaPath) !== "file") {
       failed.push({ note: "missing meta.yml", taskId: task.id });
       continue;
@@ -517,14 +644,14 @@ async function approvePlans(projectRoot, tasks, approvedAt) {
       failed.push({ note: "missing plan.md", taskId: task.id });
       continue;
     }
-    const planContent = await readFile3(planPath, "utf8");
+    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 readFile3(metaPath, "utf8"),
+      await readFile4(metaPath, "utf8"),
       approvedAt,
       totalSteps
     );
@@ -547,8 +674,8 @@ function createPlanApprovedAt(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/core/spec-approve.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
 function filterApprovalCandidates(tasks) {
   return tasks.filter((task) => task.status === "PENDING_SPEC_APPROVAL");
 }
@@ -583,11 +710,11 @@ function updateSpecApprovalBlock(metaContent, approvedAt) {
 async function approveSpecs(projectRoot, tasks, approvedAt) {
   validateSpecApprovalTargets(tasks);
   for (const task of tasks) {
-    const metaPath = join6(projectRoot, task.path, "meta.yml");
+    const metaPath = join7(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);
+    const updatedContent = updateSpecApprovalBlock(await readFile5(metaPath, "utf8"), approvedAt);
     await writeFile3(metaPath, updatedContent, "utf8");
   }
   return {
@@ -605,8 +732,8 @@ function createSpecApprovedAt(date = /* @__PURE__ */ new Date()) {
 }
 
 // src/core/start.ts
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
 function normalizeSlug(input) {
   return input.trim().toLowerCase().replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -653,7 +780,7 @@ function renderInitialMeta(input) {
 }
 async function resolveSpecTemplatePath(type) {
   const assetsRoot = await getBundledAssetsRoot();
-  return join7(assetsRoot, resolveSpecTemplateRelativePath(type));
+  return join8(assetsRoot, resolveSpecTemplateRelativePath(type));
 }
 function applyTemplateDefaults(template, type, slug, currentDate) {
   const displayName = slug.replace(/-/g, " ");
@@ -673,7 +800,7 @@ async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE
   }
   const workspaceId = createWorkspaceId(currentDate, rawType, slug);
   const workspacePath = getProjectRelativeSduckWorkspacePath(workspaceId);
-  const absoluteWorkspacePath = join7(projectRoot, workspacePath);
+  const absoluteWorkspacePath = join8(projectRoot, workspacePath);
   if (await getFsEntryKind(absoluteWorkspacePath) !== "missing") {
     throw new Error(`Workspace already exists: ${workspacePath}`);
   }
@@ -684,7 +811,7 @@ async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE
   if (await getFsEntryKind(templatePath) !== "file") {
     throw new Error(`Missing spec template for type '${rawType}' at ${templatePath}`);
   }
-  const specTemplate = await readFile5(templatePath, "utf8");
+  const specTemplate = await readFile6(templatePath, "utf8");
   const specContent = applyTemplateDefaults(specTemplate, rawType, slug, currentDate);
   const metaContent = renderInitialMeta({
     createdAt: formatUtcTimestamp(currentDate),
@@ -692,9 +819,9 @@ async function startTask(rawType, rawSlug, projectRoot, currentDate = /* @__PURE
     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");
+  await writeFile4(join8(absoluteWorkspacePath, "meta.yml"), metaContent, "utf8");
+  await writeFile4(join8(absoluteWorkspacePath, "spec.md"), specContent, "utf8");
+  await writeFile4(join8(absoluteWorkspacePath, "plan.md"), "", "utf8");
   return {
     workspaceId,
     workspacePath,
@@ -761,9 +888,9 @@ async function createFastTrackTask(input, projectRoot) {
     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");
+  const taskPath = join9(projectRoot, startedTask.workspacePath);
+  const specPath = join9(taskPath, "spec.md");
+  const planPath = join9(taskPath, "plan.md");
   if (await getFsEntryKind(specPath) !== "file") {
     throw new Error(`Missing spec.md for fast-track task ${startedTask.workspaceId}.`);
   }
@@ -900,9 +1027,15 @@ async function runFastTrackCommand(input, projectRoot) {
 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 { readFile as readFile7 } from "fs/promises";
+import { dirname as dirname2, join as join10 } 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");
+function needsClaudeCodeHook(agents) {
+  return agents.includes("claude-code");
+}
 var SDD_RULES_BEGIN = "<!-- sduck:begin -->";
 var SDD_RULES_END = "<!-- sduck:end -->";
 var SUPPORTED_AGENTS = [
@@ -920,12 +1053,12 @@ var AGENT_RULE_TARGETS = [
   { agentId: "gemini-cli", outputPath: "GEMINI.md", kind: "root-file" },
   {
     agentId: "cursor",
-    outputPath: join9(".cursor", "rules", "sduck-core.mdc"),
+    outputPath: join10(".cursor", "rules", "sduck-core.mdc"),
     kind: "managed-file"
   },
   {
     agentId: "antigravity",
-    outputPath: join9(".agents", "rules", "sduck-core.md"),
+    outputPath: join10(".agents", "rules", "sduck-core.md"),
     kind: "managed-file"
   }
 ];
@@ -986,8 +1119,8 @@ function renderManagedBlock(lines) {
 async function getAgentRulesAssetRoot() {
   const currentDirectoryPath = dirname2(fileURLToPath2(import.meta.url));
   const candidatePaths = [
-    join9(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets", "agent-rules"),
-    join9(currentDirectoryPath, "..", ".sduck", "sduck-assets", "agent-rules")
+    join10(currentDirectoryPath, "..", "..", ".sduck", "sduck-assets", "agent-rules"),
+    join10(currentDirectoryPath, "..", ".sduck", "sduck-assets", "agent-rules")
   ];
   for (const candidatePath of candidatePaths) {
     if (await getFsEntryKind(candidatePath) === "directory") {
@@ -997,7 +1130,7 @@ async function getAgentRulesAssetRoot() {
   throw new Error("Unable to locate bundled sduck agent rule assets.");
 }
 async function readAssetFile(assetRoot, fileName) {
-  return await readFile6(join9(assetRoot, fileName), "utf8");
+  return await readFile7(join10(assetRoot, fileName), "utf8");
 }
 function buildRootFileLines(agentIds, agentSpecificContent) {
   const labels = SUPPORTED_AGENTS.filter((agent) => agentIds.includes(agent.id)).map(
@@ -1059,8 +1192,8 @@ function planAgentRuleActions(mode, targets, existingEntries, existingContents)
 }
 
 // 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";
+import { chmod, mkdir as mkdir3, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname3, join as join11 } from "path";
 var ASSET_TEMPLATE_DEFINITIONS = [
   {
     key: "eval-spec",
@@ -1173,7 +1306,7 @@ async function collectExistingEntries(projectRoot) {
   for (const definition of ASSET_TEMPLATE_DEFINITIONS) {
     existingEntries.set(
       definition.relativePath,
-      await getFsEntryKind(join10(projectRoot, definition.relativePath))
+      await getFsEntryKind(join11(projectRoot, definition.relativePath))
     );
   }
   return existingEntries;
@@ -1181,9 +1314,9 @@ async function collectExistingEntries(projectRoot) {
 async function collectExistingFileContents(projectRoot, targets) {
   const contents = /* @__PURE__ */ new Map();
   for (const target of targets) {
-    const targetPath = join10(projectRoot, target.outputPath);
+    const targetPath = join11(projectRoot, target.outputPath);
     if (await getFsEntryKind(targetPath) === "file") {
-      contents.set(target.outputPath, await readFile7(targetPath, "utf8"));
+      contents.set(target.outputPath, await readFile8(targetPath, "utf8"));
     }
   }
   return contents;
@@ -1246,8 +1379,8 @@ async function initProject(options, projectRoot) {
       continue;
     }
     const definition = ASSET_TEMPLATE_MAP[action.key];
-    const sourcePath = join10(assetSourceRoot, toBundledAssetRelativePath(definition.relativePath));
-    const targetPath = join10(projectRoot, definition.relativePath);
+    const sourcePath = join11(assetSourceRoot, toBundledAssetRelativePath(definition.relativePath));
+    const targetPath = join11(projectRoot, definition.relativePath);
     await ensureReadableFile(sourcePath);
     await mkdir3(dirname3(targetPath), { recursive: true });
     await copyFileIntoPlace(sourcePath, targetPath);
@@ -1257,7 +1390,7 @@ async function initProject(options, projectRoot) {
   for (const target of agentTargets) {
     agentEntryKinds.set(
       target.outputPath,
-      await getFsEntryKind(join10(projectRoot, target.outputPath))
+      await getFsEntryKind(join11(projectRoot, target.outputPath))
     );
   }
   const existingContents = await collectExistingFileContents(projectRoot, agentTargets);
@@ -1269,6 +1402,9 @@ async function initProject(options, projectRoot) {
     summary,
     resolvedOptions.agents
   );
+  if (needsClaudeCodeHook(resolvedOptions.agents)) {
+    await installClaudeCodeHook(projectRoot, summary);
+  }
   return {
     mode,
     agents: resolvedOptions.agents,
@@ -1276,9 +1412,54 @@ async function initProject(options, projectRoot) {
     didChange: summary.created.length > 0 || summary.prepended.length > 0 || summary.overwritten.length > 0
   };
 }
+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);
+  await mkdir3(dirname3(hookTargetPath), { recursive: true });
+  await copyFileIntoPlace(hookSourcePath, hookTargetPath);
+  await chmod(hookTargetPath, 493);
+  summary.created.push(CLAUDE_CODE_HOOK_SCRIPT_PATH);
+  summary.rows.push({ path: CLAUDE_CODE_HOOK_SCRIPT_PATH, status: "created" });
+  const hookConfig = {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "Edit|Write",
+          hooks: [
+            {
+              type: "command",
+              command: '"$CLAUDE_PROJECT_DIR"/.claude/hooks/sdd-guard.sh'
+            }
+          ]
+        }
+      ]
+    }
+  };
+  if (await getFsEntryKind(settingsPath) === "file") {
+    const existingContent = await readFile8(settingsPath, "utf8");
+    try {
+      const existing = JSON.parse(existingContent);
+      existing["hooks"] = hookConfig.hooks;
+      await writeFile6(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");
+      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");
+    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 = join10(projectRoot, action.outputPath);
+    const targetPath = join11(projectRoot, action.outputPath);
     const content = await renderAgentRuleContent(action, selectedAgents);
     if (action.mergeMode === "create") {
       await mkdir3(dirname3(targetPath), { recursive: true });
@@ -1323,16 +1504,16 @@ async function applyAgentRuleActions(projectRoot, actions, existingContents, sum
 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) {
+function padCell3(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 header = `| ${padCell3("Status", statusWidth)} | ${padCell3("Path", pathWidth)} |`;
   const body = rows.map(
-    (row) => `| ${padCell2(row.status, statusWidth)} | ${padCell2(row.path, pathWidth)} |`
+    (row) => `| ${padCell3(row.status, statusWidth)} | ${padCell3(row.path, pathWidth)} |`
   );
   return [border, header, border, ...body, border].join("\n");
 }
@@ -1399,10 +1580,10 @@ async function runInitCommand(options, projectRoot) {
 
 // src/commands/plan-approve.ts
 import { checkbox as checkbox2 } from "@inquirer/prompts";
-function padCell3(value, width) {
+function padCell4(value, width) {
   return value.padEnd(width, " ");
 }
-function buildResultTable2(result) {
+function buildResultTable3(result) {
   const rows = [
     ...result.succeeded.map((row) => ({
       note: row.note,
@@ -1422,9 +1603,9 @@ function buildResultTable2(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 = `| ${padCell3("Result", resultWidth)} | ${padCell3("Task", taskWidth)} | ${padCell3("Steps", stepsWidth)} | ${padCell3("Note", noteWidth)} |`;
+  const header = `| ${padCell4("Result", resultWidth)} | ${padCell4("Task", taskWidth)} | ${padCell4("Steps", stepsWidth)} | ${padCell4("Note", noteWidth)} |`;
   const body = rows.map(
-    (row) => `| ${padCell3(row.result, resultWidth)} | ${padCell3(row.task, taskWidth)} | ${padCell3(row.steps, stepsWidth)} | ${padCell3(row.note, noteWidth)} |`
+    (row) => `| ${padCell4(row.result, resultWidth)} | ${padCell4(row.task, taskWidth)} | ${padCell4(row.steps, stepsWidth)} | ${padCell4(row.note, noteWidth)} |`
   );
   return [border, header, border, ...body, border].join("\n");
 }
@@ -1432,7 +1613,7 @@ function formatTaskLabel(task) {
   return `${task.id} (${task.status})`;
 }
 function formatSuccess2(result) {
-  const lines = [buildResultTable2(result)];
+  const lines = [buildResultTable3(result)];
   if (result.succeeded.length > 0) {
     lines.push("", "\uC0C1\uD0DC: IN_PROGRESS \u2192 \uC791\uC5C5\uC744 \uC2DC\uC791\uD569\uB2C8\uB2E4.");
   }
@@ -1467,7 +1648,7 @@ async function runPlanApproveCommand(input, projectRoot) {
     if (result.succeeded.length === 0) {
       return {
         exitCode: 1,
-        stderr: buildResultTable2(result),
+        stderr: buildResultTable3(result),
         stdout: ""
       };
     }
@@ -1567,7 +1748,7 @@ async function runStartCommand(type, slug, projectRoot) {
 // package.json
 var package_default = {
   name: "@sduck/sduck-cli",
-  version: "0.1.3",
+  version: "0.1.5",
   description: "Spec-Driven Development CLI bootstrap",
   type: "module",
   bin: {
@@ -1719,6 +1900,19 @@ program.command("done [target]").description("Complete an in-progress task after
     process.exitCode = result.exitCode;
   }
 });
+program.command("archive").description("Archive completed tasks into monthly directories").option("--keep <n>", "Keep the N most recently completed tasks in workspace", "0").action(async (options) => {
+  const keep = Number(options.keep);
+  const result = await runArchiveCommand({ keep }, 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);
 });