schub 0.1.2 → 0.1.4

package/src/changes.ts

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { type FrontmatterData, readFrontmatter, updateFrontmatterValue } from "./frontmatter";
 import { resolveSchubRoot } from "./schub-root";
 import { resolveTemplatePath } from "./templates";
 
@@ -11,8 +12,19 @@ export type ChangeInfo = {
   path: string;
 };
 
-const CHANGE_ID_PATTERN = /^(?:[Cc]\d{3}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
+export type ChangeOverviewInfo = ChangeInfo & {
+  statusLabel: string;
+  statusOrder: number;
+};
+export type ChangeDetail = {
+  changeId: string;
+  created: string;
+  status: string;
+  input: string;
+  summary: string;
+};
+const CHANGE_ID_PATTERN = /^(?:[Cc]\d+_)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SUMMARY_FALLBACK = "No summary provided.";
 const isDirectory = (path: string) => {
   try {
     return statSync(path).isDirectory();
@@ -20,28 +32,52 @@ const isDirectory = (path: string) => {
     return false;
   }
 };
-
+const readFrontmatterString = (data: FrontmatterData, key: string) => {
+  const value = data[key];
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  return "";
+};
 const parseProposal = (content: string, changeId: string) => {
   const titleMatch = content.match(/^#\s+Proposal\s+-\s+(.*)$/m);
-  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/m);
+  const { data } = readFrontmatter(content);
+  const status = readFrontmatterString(data, "status");
 
   return {
     title: titleMatch?.[1]?.trim() ?? changeId,
-    status: statusMatch?.[1]?.trim() ?? "unknown",
+    status: status || "unknown",
   };
 };
+const parseProposalSummary = (content: string) => {
+  const summaryMatch = content.match(/(?:^|\n)##\s+Summary[^\S\r\n]*\n([\s\S]*?)(?:\n##\s|\n#\s|$)/);
+  const summary = summaryMatch?.[1]?.trim() ?? "";
+  return summary || SUMMARY_FALLBACK;
+};
+const parseProposalDetail = (content: string, changeId: string) => {
+  const { data, body } = readFrontmatter(content);
+  const status = readFrontmatterString(data, "status");
+  const storedChangeId = readFrontmatterString(data, "change_id");
+  const created = readFrontmatterString(data, "created");
+  const input = readFrontmatterString(data, "input");
 
+  return {
+    changeId: storedChangeId || changeId,
+    created,
+    status: status || "unknown",
+    input,
+    summary: parseProposalSummary(body),
+  };
+};
 export const normalizeChangeId = (value: string) => {
   const trimmed = value.trim();
-  const match = trimmed.match(/^([Cc])(\d{3})_(.+)$/);
+  const match = trimmed.match(/^([Cc])(\d+)_(.+)$/);
   if (match) {
     return `C${match[2]}_${match[3]}`;
   }
   return trimmed;
 };
-
 export const isValidChangeId = (value: string) => CHANGE_ID_PATTERN.test(value.trim());
-
 export const readChangeSummary = (schubDir: string, changeId: string) => {
   const trimmed = changeId.trim();
   if (!trimmed) {
@@ -49,7 +85,7 @@ export const readChangeSummary = (schubDir: string, changeId: string) => {
   }
 
   if (!isValidChangeId(trimmed)) {
-    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`);
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C1_add-user-auth).`);
   }
 
   const normalized = normalizeChangeId(trimmed);
@@ -72,7 +108,19 @@ export const readChangeSummary = (schubDir: string, changeId: string) => {
     proposalPath,
   };
 };
+export const readChangeDetail = (schubDir: string, changeId: string) => {
+  const summary = readChangeSummary(schubDir, changeId);
+  const content = readFileSync(summary.proposalPath, "utf8");
+  const detail = parseProposalDetail(content, summary.changeId);
 
+  return {
+    changeId: detail.changeId,
+    created: detail.created,
+    status: detail.status,
+    input: detail.input,
+    summary: detail.summary,
+  };
+};
 export const updateChangeStatus = (schubDir: string, changeId: string, status: string) => {
   const nextStatus = status.trim();
   if (!nextStatus) {
@@ -81,16 +129,16 @@ export const updateChangeStatus = (schubDir: string, changeId: string, status: s
 
   const summary = readChangeSummary(schubDir, changeId);
   const content = readFileSync(summary.proposalPath, "utf8");
-  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/m);
-  const previousStatus = statusMatch?.[1]?.trim();
+  const { data } = readFrontmatter(content);
+  const previousStatus = readFrontmatterString(data, "status");
 
   if (!previousStatus) {
     throw new Error(
-      `Proposal status not found in ${summary.proposalPath}.\nAdd a '**Status**: <value>' line before updating status.`,
+      `Proposal status not found in ${summary.proposalPath}.\nAdd a 'status' field in frontmatter before updating status.`,
     );
   }
 
-  const updated = content.replace(/^\*\*Status\*\*:\s*(.+)$/m, `**Status**: ${nextStatus}`);
+  const updated = updateFrontmatterValue(content, "status", nextStatus);
   writeFileSync(summary.proposalPath, updated, "utf8");
 
   return {
@@ -100,32 +148,46 @@ export const updateChangeStatus = (schubDir: string, changeId: string, status: s
     status: nextStatus,
   };
 };
+export const archiveChange = (schubDir: string, changeId: string) => {
+  const summary = readChangeSummary(schubDir, changeId);
+  const archiveRoot = join(schubDir, "archive", "changes");
+  const archivePath = join(archiveRoot, summary.changeId);
 
+  if (existsSync(archivePath)) {
+    throw new Error(`Archive already exists: ${archivePath}`);
+  }
+
+  mkdirSync(archiveRoot, { recursive: true });
+
+  const updated = updateChangeStatus(schubDir, summary.changeId, "Archived");
+  renameSync(summary.changeDir, archivePath);
+
+  return {
+    changeId: updated.changeId,
+    previousStatus: updated.previousStatus,
+    status: updated.status,
+    proposalPath: join(archivePath, "proposal.md"),
+    archivePath,
+  };
+};
 const changeNumber = (id: string) => {
   const match = id.match(/\d+/);
   return match ? Number(match[0]) : Number.POSITIVE_INFINITY;
 };
-
-export const listChanges = (schubDir: string) => {
-  const changesRoot = join(schubDir, "changes");
+const readChangesFromRoot = (changesRoot: string, repoRoot: string) => {
   if (!existsSync(changesRoot) || !isDirectory(changesRoot)) {
     return [];
   }
-
-  const repoRoot = dirname(schubDir);
   const entries = readdirSync(changesRoot, { withFileTypes: true });
   const changes: ChangeInfo[] = [];
-
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-
     const proposalPath = join(changesRoot, entry.name, "proposal.md");
     if (!existsSync(proposalPath)) {
       continue;
     }
-
     const content = readFileSync(proposalPath, "utf8");
     const parsed = parseProposal(content, entry.name);
     changes.push({
@@ -135,58 +197,96 @@ export const listChanges = (schubDir: string) => {
       path: relative(repoRoot, proposalPath),
     });
   }
-
-  return changes.sort((a, b) => {
-    const numberDiff = changeNumber(a.id) - changeNumber(b.id);
+  return changes;
+};
+export const listChanges = (schubDir: string) => {
+  const repoRoot = dirname(schubDir);
+  const changes = readChangesFromRoot(join(schubDir, "changes"), repoRoot);
+  return changes.sort((left, right) => {
+    const numberDiff = changeNumber(left.id) - changeNumber(right.id);
     if (numberDiff !== 0) {
       return numberDiff;
     }
-    return a.id.localeCompare(b.id);
+    return left.id.localeCompare(right.id);
+  });
+};
+const STATUS_GROUPS = [
+  { label: "Draft", match: "draft" },
+  { label: "Pending Review", match: "review" },
+  { label: "Accepted", match: "accepted" },
+  { label: "Implementing", match: "implement" },
+  { label: "Done", match: "done" },
+  { label: "Archived", match: "archiv" },
+];
+
+const normalizeStatusLabel = (status: string) => {
+  const trimmed = status.trim();
+  const normalized = trimmed.toLowerCase();
+  for (const [index, group] of STATUS_GROUPS.entries()) {
+    if (normalized.includes(group.match)) {
+      return { label: group.label, order: index };
+    }
+  }
+  const label = trimmed
+    .split(/\s+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+  return { label: label || "Unknown", order: STATUS_GROUPS.length };
+};
+export const listChangeOverview = (schubDir: string) => {
+  const repoRoot = dirname(schubDir);
+  const combined = new Map<string, ChangeInfo>();
+  for (const root of [join(schubDir, "changes"), join(schubDir, "archive", "changes")]) {
+    for (const change of readChangesFromRoot(root, repoRoot)) {
+      if (!combined.has(change.id)) {
+        combined.set(change.id, change);
+      }
+    }
+  }
+  return Array.from(combined.values()).map((change) => {
+    const normalized = normalizeStatusLabel(change.status);
+    return {
+      ...change,
+      statusLabel: normalized.label,
+      statusOrder: normalized.order,
+    };
   });
 };
-
 const slugify = (value: string) => {
   let slug = value.trim().toLowerCase();
   slug = slug.replace(/[^a-z0-9]+/g, "-");
   slug = slug.replace(/-{2,}/g, "-");
   return slug.replace(/^-|-$/g, "");
 };
-
 const splitPrefixedChangeId = (changeId: string) => {
-  const match = changeId.match(/^([Cc])(\d{3})_([a-z0-9]+(?:-[a-z0-9]+)*)$/);
+  const match = changeId.match(/^([Cc])(\d+)_([a-z0-9]+(?:-[a-z0-9]+)*)$/);
   if (match) {
     return { prefix: match[2], slug: match[3] };
   }
   return { prefix: null, slug: changeId };
 };
-
 const nextChangePrefix = (schubDir: string) => {
   const changesRoot = join(schubDir, "changes");
   const archiveRoot = join(schubDir, "archive", "changes");
   const prefixes: number[] = [];
-
   const scan = (root: string) => {
     if (!existsSync(root) || !isDirectory(root)) return;
     for (const entry of readdirSync(root, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const match = entry.name.match(/^[Cc](\d{3})_/);
+      const match = entry.name.match(/^[Cc](\d+)_/);
       if (match) {
         prefixes.push(Number.parseInt(match[1], 10));
       }
     }
   };
-
   scan(changesRoot);
   scan(archiveRoot);
-
   const next = prefixes.length > 0 ? Math.max(...prefixes) + 1 : 1;
-  return next.toString().padStart(3, "0");
+  return next.toString().padStart(4, "0");
 };
-
 const CHANGE_PREFIX = "C";
-
 const BUNDLED_PROPOSAL_TEMPLATE_PATH = fileURLToPath(
   new URL("../templates/create-proposal/proposal-template.md", import.meta.url),
 );
@@ -203,31 +303,36 @@ const readProposalTemplate = (schubDir: string) => {
     throw new Error(`[ERROR] Template not found: ${templatePath}`);
   }
 };
-
 const isValidSlug = (value: string) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-
 const changeExists = (schubDir: string, changeId: string) => {
   const active = join(schubDir, "changes", changeId);
   if (existsSync(active)) {
     return true;
   }
-
   const archiveRoot = join(schubDir, "archive", "changes");
   if (!existsSync(archiveRoot) || !isDirectory(archiveRoot)) {
     return false;
   }
-
   for (const entry of readdirSync(archiveRoot, { withFileTypes: true })) {
     if (entry.isDirectory() && entry.name.includes(changeId)) {
       return true;
     }
   }
-
   return false;
 };
-
+const findChangeByPrefix = (schubDir: string, prefix: string) => {
+  const normalizedPrefix = prefix.toUpperCase();
+  for (const root of [join(schubDir, "changes"), join(schubDir, "archive", "changes")]) {
+    if (!existsSync(root) || !isDirectory(root)) continue;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.toUpperCase().startsWith(`${normalizedPrefix}_`)) {
+        return entry.name;
+      }
+    }
+  }
+  return null;
+};
 export const resolveChangeRoot = resolveSchubRoot;
-
 export const createChange = (
   schubDir: string,
   options: { changeId?: string; title?: string; input?: string; overwrite?: boolean },
@@ -235,7 +340,6 @@ export const createChange = (
   let changeId = (options.changeId || "").trim();
   let title = (options.title || "").trim();
   const input = (options.input || "").trim();
-
   if (!changeId) {
     if (!title) {
       throw new Error("Provide --change-id or --title.");
@@ -246,13 +350,11 @@ export const createChange = (
     }
     console.warn(`[WARN] Derived change-id '${changeId}' from --title. Prefer verb-led ids.`);
   }
-
   const originalChangeId = changeId;
   const { prefix: existingPrefix, slug } = splitPrefixedChangeId(changeId);
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid change-id '${changeId}'. Use kebab-case (lowercase letters/digits and hyphens).`);
   }
-
   if (!existingPrefix) {
     const prefix = nextChangePrefix(schubDir);
     changeId = `${CHANGE_PREFIX}${prefix}_${slug}`;
@@ -263,18 +365,24 @@ export const createChange = (
       console.error(`[INFO] Normalized change-id to '${changeId}'.`);
     }
   }
-
   if (!title) {
     title = slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   }
-
+  const prefixMatch = changeId.match(/^([Cc]\d+)_/);
+  if (prefixMatch) {
+    const prefix = prefixMatch[1].toUpperCase();
+    const existing = findChangeByPrefix(schubDir, prefix);
+    if (existing && existing !== changeId) {
+      throw new Error(
+        `Change prefix '${prefix}' already exists as '${existing}'. Choose a new prefix or omit it to auto-generate.`,
+      );
+    }
+  }
   const changeDir = join(schubDir, "changes", changeId);
   const proposalPath = join(changeDir, "proposal.md");
-
   if (changeExists(schubDir, changeId) && !options.overwrite) {
     throw new Error(`Change '${changeId}' already exists under ${schubDir}. Choose a unique id or pass --overwrite.`);
   }
-
   const template = readProposalTemplate(schubDir);
   const today = new Date().toISOString().split("T")[0];
   const rendered = template
@@ -283,13 +391,10 @@ export const createChange = (
     .replace("{{DATE}}", today)
     .replace("{{INPUT}}", input || "[no input provided]")
     .replace("{{AGENT_ROOT}}", schubDir);
-
   if (existsSync(proposalPath) && !options.overwrite) {
     throw new Error(`Refusing to overwrite existing file: ${proposalPath}`);
   }
-
   mkdirSync(changeDir, { recursive: true });
   writeFileSync(proposalPath, rendered, "utf8");
-
   return proposalPath;
 };

package/src/commands/adr.test.ts

@@ -37,19 +37,20 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
   const proposal = [
+    "---",
+    `change_id: ${changeId}`,
+    "created: 2024-01-01",
+    "status: Draft",
+    "---",
     `# Proposal - ${title}`,
     "",
-    `**Change ID**: \`${changeId}\``,
-    "**Created**: 2024-01-01",
-    "**Status**: Draft",
-    "",
   ].join("\n");
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };
 
 test("adr create scaffolds ADR file", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C003_new-adr";
+  const changeId = "C0003_new-adr";
   const changeTitle = "New ADR";
   seedChange(schubRoot, changeId, changeTitle);
 

package/src/commands/changes.test.ts

@@ -1,7 +1,7 @@
 import { expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "bun";
 
@@ -38,6 +38,34 @@ const runChangesStatus = (schubCwd: string, args: string[] = []) => {
   };
 };
 
+const runChangesArchive = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "changes", "archive", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const runChangesList = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "changes", "list", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
 const createRepo = () => {
   const base = mkdtempSync(join(tmpdir(), "schub-changes-"));
   const repoRoot = join(base, "repo");
@@ -52,17 +80,27 @@ const seedChange = (schubRoot: string, changeId: string) => {
   writeFileSync(join(changeDir, "proposal.md"), "# Proposal - Seed\n", "utf8");
 };
 
-const seedProposal = (schubRoot: string, changeId: string, status: string) => {
+const seedProposal = (schubRoot: string, changeId: string, status: string, title = "Seed") => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
-  const proposal = `# Proposal - Seed\n**Status**: ${status}\n`;
+  const proposal = `---\nstatus: ${status}\n---\n# Proposal - ${title}\n`;
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };
 
+const seedTask = (schubRoot: string, status: string, taskId: string, changeId: string, titleSlug = "seed-task") => {
+  const taskDir = join(schubRoot, "tasks", status);
+  mkdirSync(taskDir, { recursive: true });
+  const fileName = `${taskId}_${titleSlug}.md`;
+  const taskPath = join(taskDir, fileName);
+  const taskBody = `---\nchange_id: ${changeId}\n---\n# Task: ${taskId} Seed\n`;
+  writeFileSync(taskPath, taskBody, "utf8");
+  return taskPath;
+};
+
 test("changes create scaffolds proposal with prefixed id", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedChange(schubRoot, "C002_existing-change");
+  seedChange(schubRoot, "C0002_existing-change");
 
   const title = "Update CLI scaffolding";
   const input = "user prompt";
@@ -77,7 +115,7 @@ test("changes create scaffolds proposal with prefixed id", () => {
 
   expect(result.exitCode).toBe(0);
 
-  const changeId = "C003_update-cli-scaffolding";
+  const changeId = "C0003_update-cli-scaffolding";
   const proposalPath = join(schubRoot, "changes", changeId, "proposal.md");
   expect(existsSync(proposalPath)).toBe(true);
 
@@ -115,7 +153,7 @@ test("changes create requires change id or title", () => {
 test("changes create respects overwrite", () => {
   const { cwd } = createRepo();
   const schubRoot = join(cwd, ".schub");
-  const changeId = "C001_repeatable-change";
+  const changeId = "C0001_repeatable-change";
 
   const first = runChangesCreate(cwd, ["--change-id", changeId, "--title", "First"]);
   expect(first.result.exitCode).toBe(0);
@@ -143,29 +181,113 @@ test("changes create rejects schub root flags", () => {
 test("changes status updates accepted proposals", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli", "Accepted");
+  seedProposal(schubRoot, "C0001_update-cli", "Accepted");
 
-  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C001_update-cli", "--status", "Done"]);
+  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C0001_update-cli", "--status", "Done"]);
 
   expect(result.exitCode).toBe(0);
 
-  const proposalPath = join(schubRoot, "changes", "C001_update-cli", "proposal.md");
+  const proposalPath = join(schubRoot, "changes", "C0001_update-cli", "proposal.md");
   const updated = readFileSync(proposalPath, "utf8");
-  expect(updated).toContain("**Status**: Done");
+  expect(updated).toContain("status: Done");
   expect(stdout).toContain("[OK] Updated status");
 });
 
 test("changes status updates WIP proposals", () => {
   const { repoRoot, cwd } = createRepo();
   const schubRoot = join(repoRoot, ".schub");
-  seedProposal(schubRoot, "C001_update-cli", "WIP");
+  seedProposal(schubRoot, "C0001_update-cli", "WIP");
 
-  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C001_update-cli", "--status", "Done"]);
+  const { result, stdout } = runChangesStatus(cwd, ["--change-id", "C0001_update-cli", "--status", "Done"]);
 
   expect(result.exitCode).toBe(0);
 
-  const proposalPath = join(schubRoot, "changes", "C001_update-cli", "proposal.md");
+  const proposalPath = join(schubRoot, "changes", "C0001_update-cli", "proposal.md");
   const updated = readFileSync(proposalPath, "utf8");
-  expect(updated).toContain("**Status**: Done");
+  expect(updated).toContain("status: Done");
   expect(stdout).toContain("[OK] Updated status");
 });
+
+test("changes list prints change summaries", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C0002_second-change", "Done", "Second Change");
+  seedProposal(schubRoot, "C0001_first-change", "Accepted", "First Change");
+
+  const { result, stdout } = runChangesList(cwd);
+
+  expect(result.exitCode).toBe(0);
+  expect(stdout.trim().split("\n")).toEqual([
+    "C0001_first-change First Change (Accepted)",
+    "C0002_second-change Second Change (Done)",
+  ]);
+});
+
+test("changes archive moves change and tasks by default", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  const changeId = "C0001_archive-change";
+  seedProposal(schubRoot, changeId, "Accepted");
+
+  const readyTask = seedTask(schubRoot, "ready", "T0001_archive-change", changeId, "ready-task");
+  const doneTask = seedTask(schubRoot, "done", "T0002_archive-change", changeId, "done-task");
+  const otherTask = seedTask(schubRoot, "backlog", "T0003_other-change", "C0002_other-change", "other-task");
+
+  const { result, stdout } = runChangesArchive(cwd, ["--change-id", changeId]);
+
+  expect(result.exitCode).toBe(0);
+  expect(stdout).toContain(`[OK] Archived change ${changeId}`);
+
+  const archivedChangePath = join(schubRoot, "archive", "changes", changeId);
+  expect(existsSync(archivedChangePath)).toBe(true);
+  expect(existsSync(join(schubRoot, "changes", changeId))).toBe(false);
+
+  const archivedReadyTask = join(schubRoot, "tasks", "archived", basename(readyTask));
+  const archivedDoneTask = join(schubRoot, "tasks", "archived", basename(doneTask));
+  expect(existsSync(archivedReadyTask)).toBe(true);
+  expect(existsSync(archivedDoneTask)).toBe(true);
+  expect(existsSync(readyTask)).toBe(false);
+  expect(existsSync(doneTask)).toBe(false);
+  expect(existsSync(otherTask)).toBe(true);
+
+  const proposalPath = join(archivedChangePath, "proposal.md");
+  const updated = readFileSync(proposalPath, "utf8");
+  expect(updated).toContain("status: Archived");
+});
+
+test("changes archive skips tasks when requested", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  const changeId = "C0001_archive-change";
+  seedProposal(schubRoot, changeId, "Accepted");
+
+  const readyTask = seedTask(schubRoot, "ready", "T0001_archive-change", changeId, "ready-task");
+
+  const { result } = runChangesArchive(cwd, ["--change-id", changeId, "--skip-tasks"]);
+
+  expect(result.exitCode).toBe(0);
+  expect(existsSync(readyTask)).toBe(true);
+  expect(existsSync(join(schubRoot, "tasks", "archived", basename(readyTask)))).toBe(false);
+  expect(existsSync(join(schubRoot, "archive", "changes", changeId))).toBe(true);
+});
+
+test("changes archive reports collisions and leaves tasks alone", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  const changeId = "C0001_archive-change";
+  seedProposal(schubRoot, changeId, "Accepted");
+
+  const readyTask = seedTask(schubRoot, "ready", "T0001_archive-change", changeId, "ready-task");
+
+  const archiveRoot = join(schubRoot, "archive", "changes", changeId);
+  mkdirSync(archiveRoot, { recursive: true });
+  writeFileSync(join(archiveRoot, "proposal.md"), "---\nstatus: Archived\n---\n# Proposal - Existing\n", "utf8");
+
+  const { result, stderr } = runChangesArchive(cwd, ["--change-id", changeId]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Archive already exists");
+  expect(existsSync(readyTask)).toBe(true);
+  expect(existsSync(join(schubRoot, "tasks", "archived", basename(readyTask)))).toBe(false);
+  expect(existsSync(join(schubRoot, "changes", changeId))).toBe(true);
+});