schub 0.1.2 → 0.1.3

package/skills/create-proposal/SKILL.md

@@ -11,7 +11,7 @@ $ARGUMENTS
 
 ## Workflow
 
-1. Derive a concise, verb-led `change-id` suffix from the request (kebab-case: `add-`, `update-`, `remove-`, `refactor-`, `fix-`) and prefix it with `C` + the next 3-digit sequence + `_` (e.g., `C001_add-user-auth`).
+1. Derive a concise, verb-led `change-id` suffix from the request (kebab-case: `add-`, `update-`, `remove-`, `refactor-`, `fix-`) and prefix it with `C` + the next 4-digit sequence + `_` (e.g., `C0001_add-user-auth`).
 2. Run `npx schub changes create --change-id "<change-id>" --title "<title>" --input "<user prompt verbatim>"` to scaffold the proposal template.
    - Supported flags: `--change-id`, `--title`, `--input`, `--overwrite`.
 3. Update the generated proposal with concrete, testable statements.

package/skills/create-tasks/SKILL.md

@@ -3,7 +3,7 @@ name: create-tasks
 description: "Break an accepted proposal into actionable task files under `.schub/tasks/` using the task template. Use when asked to create tasks for a change-id."
 ---
 
-## User Input (should contain change-id or shorthand `C###`)
+## User Input (should contain change-id or shorthand `C####`)
 
 ```text
 $ARGUMENTS
@@ -11,13 +11,13 @@ $ARGUMENTS
 
 ## Workflow
 
-1. If the user provides shorthand `C###`, resolve it to the matching `C###_<suffix>` change folder (error if ambiguous). Confirm `.schub/changes/<change-id>/proposal.md` exists and that it is marked accepted. If it is missing, ask the user to run the create-proposal skill first. If it is still a draft, ask the user to review it first.
+1. If the user provides shorthand `C####`, resolve it to the matching `C####_<suffix>` change folder (error if ambiguous). Confirm `.schub/changes/<change-id>/proposal.md` exists and that it is marked accepted. If it is missing, ask the user to run the create-proposal skill first. If it is still a draft, ask the user to review it first.
 2. Read the proposal and other files in the <change-id> folder.
 3. Derive tasks, each task should be:
    - Small enough to implement in one sitting.
    - Independently testable.
    - Explicit about file paths and affected components.
-4. Assign a unique task id using `T###` (ex: `T001`) and avoid collisions with existing tasks.
+4. Assign a unique task id using `T####` (ex: `T0001`) and avoid collisions with existing tasks.
 5. Run `npx schub tasks create --change-id "<change-id>" --title "<task title>"` to scaffold tasks.
    - Repeat `--title` for multiple tasks.
    - Optional flags: `--status "<status>"` (default: `backlog`), `--overwrite`.

package/skills/review-proposal/SKILL.md

@@ -3,7 +3,7 @@ name: review-proposal
 description: "Run a review session for a proposal by creating a list of open questions, updating the proposal, adding a Q&A section, and deleting REVIEW_ME.md on completion. Use when asked to review proposals."
 ---
 
-## User Input (change-id or shorthand `C###`)
+## User Input (change-id or shorthand `C####`)
 
 ```text
 $ARGUMENTS
@@ -11,7 +11,7 @@ $ARGUMENTS
 
 ## Workflow
 
-0. If the user provides shorthand `C###`, resolve it to the matching `C###_<suffix>` change folder (error if ambiguous). Mark the proposal Status as "In Review"
+0. If the user provides shorthand `C####`, resolve it to the matching `C####_<suffix>` change folder (error if ambiguous). Mark the proposal Status as "In Review"
 1. Review the proposal by checking the [MISSING INFORMATION] tags and the potential issues listed.
 2. If there are issues, or missing information, run `npx schub review create --change-id "<change-id>"` to scaffold `.schub/changes/<change-id>/REVIEW_ME.md`.
 3. Triage each item:

package/src/App.test.tsx

@@ -15,6 +15,12 @@ const displaySchubDir =
 const ansiPattern = new RegExp(`${String.fromCharCode(27)}[[0-9;]*m`, "g");
 const stripAnsi = (value: string) => value.replace(ansiPattern, "");
 
+const writeProposal = (changesRoot: string, changeId: string, status: string, title = changeId) => {
+  const changeDir = join(changesRoot, changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), `# Proposal - ${title}\n**Status**: ${status}\n`, "utf8");
+};
+
 test("renders tabs with header and footer details", () => {
   const { lastFrame } = render(<App />);
   const output = stripAnsi(lastFrame() || "");
@@ -27,6 +33,51 @@ test("renders tabs with header and footer details", () => {
   expect(output).toContain(packageJson.version);
 });
 
+test("shows review shortcut when pending review proposal is selected", async () => {
+  const originalCwd = process.cwd();
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-review-shortcut-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, "C001_pending-review", "Pending Review");
+
+  try {
+    process.chdir(baseDir);
+    const rendered = render(<App />);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const output = stripAnsi(rendered.lastFrame() ?? "");
+    expect(output).toContain("[r review]");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("hides review shortcut when selection moves off pending review", async () => {
+  const originalCwd = process.cwd();
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-review-hide-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, "C001_pending-review", "Pending Review");
+  writeProposal(changesRoot, "C002_draft", "Draft");
+
+  try {
+    process.chdir(baseDir);
+    const rendered = render(<App />);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const initial = stripAnsi(rendered.lastFrame() ?? "");
+    expect(initial).toContain("[r review]");
+
+    rendered.stdin.write("\u001B[B");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    const moved = stripAnsi(rendered.lastFrame() ?? "");
+    expect(moved).not.toContain("[r review]");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
 test("selected tab shows a blue left indicator", () => {
   const originalForceColor = process.env.FORCE_COLOR;
   process.env.FORCE_COLOR = "1";
@@ -56,15 +107,16 @@ test("shows a copy banner after copying an item", async () => {
   };
 
   mkdirSync(readyRoot, { recursive: true });
-  writeFileSync(join(readyRoot, "T900_copy-task.md"), "# Task: T900 Copy Task\n", "utf8");
+  writeFileSync(join(readyRoot, "T0900_copy-task.md"), "# Task: T0900 Copy Task\n", "utf8");
 
   try {
     process.chdir(baseDir);
     const rendered = render(<App copyToClipboard={recordCopy} />);
     rendered.stdin.write("c");
     await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => setTimeout(resolve, 0));
     const output = rendered.lastFrame() ?? "";
-    expect(copied).toBe("T900");
+    expect(copied).toBe("T0900");
     expect(output).toContain("Copied to clipboard !");
   } finally {
     process.chdir(originalCwd);

package/src/App.tsx

@@ -14,6 +14,11 @@ type TabDefinition = {
   label: string;
 };
 
+type Shortcut = {
+  keyLabel: string;
+  label: string;
+};
+
 const tabs: TabDefinition[] = [
   { id: "status", label: "Status" },
   { id: "plan", label: "Plan" },
@@ -34,6 +39,7 @@ export default function App({ copyToClipboard = copyToClipboardDefault }: AppPro
     rows: stdout.rows,
   }));
   const [copyBanner, setCopyBanner] = React.useState<string | null>(null);
+  const [statusShortcuts, setStatusShortcuts] = React.useState<Shortcut[]>([]);
   const versionLabel = `${packageJson.version}`;
   const homeDir = homedir();
   const startDir = process.env.SCHUB_CWD ?? process.cwd();
@@ -81,15 +87,22 @@ export default function App({ copyToClipboard = copyToClipboardDefault }: AppPro
     }
   });
 
+  React.useEffect(() => {
+    if (mode !== "status") {
+      setStatusShortcuts([]);
+    }
+  }, [mode]);
+
   const handleCopyId = (value: string) => {
     copyToClipboard(value);
     setCopyBanner(COPY_BANNER_TEXT);
   };
 
-  const shortcuts = [
+  const baseShortcuts: Shortcut[] = [
     { keyLabel: "o", label: "open file" },
     { keyLabel: "c", label: "copy" },
   ];
+  const shortcuts = mode === "status" ? [...baseShortcuts, ...statusShortcuts] : baseShortcuts;
 
   return (
     <Box backgroundColor="black" flexDirection="column" width={dimensions.columns} height={dimensions.rows}>
@@ -127,7 +140,11 @@ export default function App({ copyToClipboard = copyToClipboardDefault }: AppPro
         </Box>
       </Box>
       <Box flexDirection="column" paddingX={2} paddingY={1} flexGrow={1} flexShrink={1}>
-        {mode === "status" ? <StatusView onCopyId={handleCopyId} /> : <PlanView onCopyId={handleCopyId} />}
+        {mode === "status" ? (
+          <StatusView onCopyId={handleCopyId} onShortcutsChange={setStatusShortcuts} />
+        ) : (
+          <PlanView onCopyId={handleCopyId} />
+        )}
       </Box>
       <Box flexDirection="column" paddingX={2} paddingBottom={1} flexShrink={0}>
         <Box justifyContent="space-between">

package/src/changes.test.ts

@@ -0,0 +1,52 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { archiveChange } from "./changes";
+
+const createSchubRoot = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-change-archive-"));
+  const schubDir = join(base, ".schub");
+  mkdirSync(schubDir, { recursive: true });
+  return { schubDir };
+};
+
+const seedProposal = (schubDir: string, changeId: string, status: string) => {
+  const changeDir = join(schubDir, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  const proposal = `# Proposal - Seed\n**Status**: ${status}\n`;
+  writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
+};
+
+test("archiveChange updates proposal and moves directory", () => {
+  const { schubDir } = createSchubRoot();
+  const changeId = "C0001_archive-change";
+  seedProposal(schubDir, changeId, "Accepted");
+
+  archiveChange(schubDir, changeId);
+
+  const archivePath = join(schubDir, "archive", "changes", changeId);
+  expect(existsSync(join(schubDir, "changes", changeId))).toBe(false);
+  expect(existsSync(archivePath)).toBe(true);
+
+  const proposalPath = join(archivePath, "proposal.md");
+  const updated = readFileSync(proposalPath, "utf8");
+  expect(updated).toContain("**Status**: Archived");
+});
+
+test("archiveChange rejects archive collisions", () => {
+  const { schubDir } = createSchubRoot();
+  const changeId = "C0001_archive-change";
+  seedProposal(schubDir, changeId, "Accepted");
+
+  const archivePath = join(schubDir, "archive", "changes", changeId);
+  mkdirSync(archivePath, { recursive: true });
+  const archivedProposal = join(archivePath, "proposal.md");
+  writeFileSync(archivedProposal, "# Proposal - Existing\n**Status**: Archived\n", "utf8");
+
+  expect(() => archiveChange(schubDir, changeId)).toThrow(`Archive already exists: ${archivePath}`);
+
+  const activeProposal = readFileSync(join(schubDir, "changes", changeId, "proposal.md"), "utf8");
+  expect(activeProposal).toContain("**Status**: Accepted");
+  expect(readFileSync(archivedProposal, "utf8")).toContain("# Proposal - Existing");
+});

package/src/changes.ts

@@ -1,4 +1,4 @@
-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 { resolveSchubRoot } from "./schub-root";
@@ -11,7 +11,7 @@ export type ChangeInfo = {
   path: string;
 };
 
-const CHANGE_ID_PATTERN = /^(?:[Cc]\d{3}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const CHANGE_ID_PATTERN = /^(?:[Cc]\d{4}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 const isDirectory = (path: string) => {
   try {
@@ -33,7 +33,7 @@ const parseProposal = (content: string, changeId: string) => {
 
 export const normalizeChangeId = (value: string) => {
   const trimmed = value.trim();
-  const match = trimmed.match(/^([Cc])(\d{3})_(.+)$/);
+  const match = trimmed.match(/^([Cc])(\d{4})_(.+)$/);
   if (match) {
     return `C${match[2]}_${match[3]}`;
   }
@@ -49,7 +49,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., C0001_add-user-auth).`);
   }
 
   const normalized = normalizeChangeId(trimmed);
@@ -101,6 +101,29 @@ export const updateChangeStatus = (schubDir: string, changeId: string, status: s
   };
 };
 
+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;
@@ -153,7 +176,7 @@ const slugify = (value: string) => {
 };
 
 const splitPrefixedChangeId = (changeId: string) => {
-  const match = changeId.match(/^([Cc])(\d{3})_([a-z0-9]+(?:-[a-z0-9]+)*)$/);
+  const match = changeId.match(/^([Cc])(\d{4})_([a-z0-9]+(?:-[a-z0-9]+)*)$/);
   if (match) {
     return { prefix: match[2], slug: match[3] };
   }
@@ -171,7 +194,7 @@ const nextChangePrefix = (schubDir: string) => {
       if (!entry.isDirectory()) {
         continue;
       }
-      const match = entry.name.match(/^[Cc](\d{3})_/);
+      const match = entry.name.match(/^[Cc](\d{4})_/);
       if (match) {
         prefixes.push(Number.parseInt(match[1], 10));
       }
@@ -182,7 +205,7 @@ const nextChangePrefix = (schubDir: string) => {
   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";

package/src/commands/adr.test.ts

@@ -49,7 +49,7 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
 
 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 = `# Proposal - ${title}\n**Status**: ${status}\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 = `# Task: ${taskId} Seed\n\n**Change ID**: ${changeId}\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,13 +181,13 @@ 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(stdout).toContain("[OK] Updated status");
@@ -158,14 +196,98 @@ test("changes status updates accepted proposals", () => {
 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(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"), "# Proposal - Existing\n**Status**: Archived\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);
+});