schub 0.1.0 → 0.1.2

package/src/commands/eject.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runEject = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "eject", ...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-eject-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+  return { repoRoot, cwd };
+};
+
+test("eject creates schub assets when missing", () => {
+  const { repoRoot } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+
+  const { result } = runEject(repoRoot);
+
+  expect(result.exitCode).toBe(0);
+  expect(existsSync(join(schubRoot, "skills"))).toBe(true);
+  expect(existsSync(join(schubRoot, "templates"))).toBe(true);
+  expect(existsSync(join(schubRoot, "skills", "create-proposal", "SKILL.md"))).toBe(true);
+});
+
+test("eject refuses to overwrite without --force", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(schubRoot, { recursive: true });
+
+  const first = runEject(cwd);
+  expect(first.result.exitCode).toBe(0);
+
+  const second = runEject(cwd);
+  expect(second.result.exitCode).not.toBe(0);
+  expect(second.stderr).toContain("--force");
+});
+
+test("eject overwrites with --force", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(schubRoot, { recursive: true });
+
+  const first = runEject(cwd);
+  expect(first.result.exitCode).toBe(0);
+
+  const sentinelPath = join(schubRoot, "skills", "sentinel.txt");
+  writeFileSync(sentinelPath, "keep me", "utf8");
+  expect(existsSync(sentinelPath)).toBe(true);
+
+  const second = runEject(cwd, ["--force"]);
+  expect(second.result.exitCode).toBe(0);
+  expect(existsSync(sentinelPath)).toBe(false);
+});

package/src/commands/eject.ts

@@ -0,0 +1,100 @@
+import { cpSync, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveSchubRoot } from "../schub-root";
+
+type EjectOptions = {
+  force: boolean;
+};
+
+const BUNDLED_SKILLS_ROOT = fileURLToPath(new URL("../../skills", import.meta.url));
+const BUNDLED_TEMPLATES_ROOT = fileURLToPath(new URL("../../templates", import.meta.url));
+
+const isDirectory = (path: string) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+const parseEjectOptions = (args: string[]) => {
+  let force = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (const arg of args) {
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  return { force };
+};
+
+const ensureBundledDir = (path: string) => {
+  if (!isDirectory(path)) {
+    throw new Error(`[ERROR] Bundled assets missing: ${path}`);
+  }
+};
+
+const removeExisting = (path: string) => {
+  if (existsSync(path)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+};
+
+const copyDirectory = (source: string, destination: string) => {
+  ensureBundledDir(source);
+  cpSync(source, destination, { recursive: true });
+};
+
+const enforceOverwrite = (paths: string[], force: boolean) => {
+  const existing = paths.filter((path) => existsSync(path));
+  if (existing.length === 0) {
+    return;
+  }
+
+  if (!force) {
+    const lines = existing.map((path) => `  - ${path}`).join("\n");
+    throw new Error(`[ERROR] Refusing to overwrite existing path(s):\n${lines}\nRe-run with --force.`);
+  }
+
+  for (const path of existing) {
+    removeExisting(path);
+  }
+};
+
+export const runEject = (args: string[], startDir: string) => {
+  const options: EjectOptions = parseEjectOptions(args);
+  const schubRoot = resolveSchubRoot(startDir);
+  mkdirSync(schubRoot, { recursive: true });
+
+  const skillsTarget = join(schubRoot, "skills");
+  const templatesTarget = join(schubRoot, "templates");
+  enforceOverwrite([skillsTarget, templatesTarget], options.force);
+
+  copyDirectory(BUNDLED_SKILLS_ROOT, skillsTarget);
+  copyDirectory(BUNDLED_TEMPLATES_ROOT, templatesTarget);
+
+  process.stdout.write(`[OK] Wrote ${skillsTarget}\n`);
+  process.stdout.write(`[OK] Wrote ${templatesTarget}\n`);
+};

package/src/commands/init.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { installCodexSkills, resolveCodexSkillsRoot, selectProviders } from "./init";
+
+const createRepoFixture = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-init-codex-"));
+  const repoRoot = join(base, "repo");
+  const startDir = join(repoRoot, "nested", "dir");
+  mkdirSync(startDir, { recursive: true });
+  return { base, repoRoot, startDir };
+};
+
+test("selectProviders handles numeric and named inputs", () => {
+  expect(selectProviders("1")).toEqual(["codex"]);
+  expect(selectProviders("codex, 1")).toEqual(["codex"]);
+});
+
+test("resolveCodexSkillsRoot prefers worktree .codex when present", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  mkdirSync(join(repoRoot, ".codex"), { recursive: true });
+
+  const destination = resolveCodexSkillsRoot(startDir);
+  const expectedRoot = realpathSync(repoRoot);
+
+  expect(destination).toBe(join(expectedRoot, ".codex", "skills"));
+});
+
+test("resolveCodexSkillsRoot falls back to home when worktree .codex is missing", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  const originalHome = process.env.HOME;
+  const homeDir = mkdtempSync(join(tmpdir(), "schub-home-"));
+  process.env.HOME = homeDir;
+
+  try {
+    const destination = resolveCodexSkillsRoot(startDir);
+    expect(destination).toBe(join(homeDir, ".codex", "skills"));
+  } finally {
+    process.env.HOME = originalHome;
+  }
+});
+
+test("resolveCodexSkillsRoot uses cwd when git is unavailable", () => {
+  const { startDir } = createRepoFixture();
+  const originalPath = process.env.PATH;
+  process.env.PATH = "";
+
+  try {
+    const destination = resolveCodexSkillsRoot(startDir);
+    expect(destination).toBe(join(startDir, ".codex", "skills"));
+  } finally {
+    process.env.PATH = originalPath;
+  }
+});
+
+test("installCodexSkills skips existing skill directories", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-init-install-"));
+  const destination = join(base, "skills");
+  const existingSkill = join(destination, "create-proposal");
+  mkdirSync(existingSkill, { recursive: true });
+  writeFileSync(join(existingSkill, "SKILL.md"), "existing", "utf8");
+
+  const { installed, skipped } = installCodexSkills(destination);
+
+  expect(skipped).toContain("create-proposal");
+  expect(installed.length).toBeGreaterThan(0);
+  expect(existsSync(join(destination, "create-tasks", "SKILL.md"))).toBe(true);
+});

package/src/commands/init.ts

@@ -0,0 +1,144 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { initSchubRoot, resolveGitRoot } from "../init";
+
+type ProviderId = "codex";
+
+type ProviderOption = {
+  id: ProviderId;
+  label: string;
+};
+
+const PROVIDERS: ProviderOption[] = [{ id: "codex", label: "Codex" }];
+const BUNDLED_SKILLS_ROOT = fileURLToPath(new URL("../../skills", import.meta.url));
+
+const isDirectory = (path: string) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+const readLine = (prompt: string) =>
+  new Promise<string>((resolveInput) => {
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    terminal.question(prompt, (answer) => {
+      terminal.close();
+      resolveInput(answer.trim());
+    });
+  });
+
+const renderProviderList = (providers: ProviderOption[]) =>
+  providers.map((provider, index) => `  ${index + 1}) ${provider.label}`).join("\n");
+
+export const selectProviders = (input: string, providers: ProviderOption[] = PROVIDERS) => {
+  const tokens = input
+    .split(/[, ]+/)
+    .map((token) => token.trim().toLowerCase())
+    .filter(Boolean);
+
+  const selected = new Set<ProviderId>();
+
+  for (const token of tokens) {
+    const index = Number.parseInt(token, 10);
+    if (!Number.isNaN(index) && index > 0 && index <= providers.length) {
+      selected.add(providers[index - 1].id);
+      continue;
+    }
+
+    const match = providers.find((provider) => provider.id === token || provider.label.toLowerCase() === token);
+    if (match) {
+      selected.add(match.id);
+    }
+  }
+
+  return Array.from(selected);
+};
+
+const promptForProviders = async () => {
+  const list = renderProviderList(PROVIDERS);
+  const answer = await readLine(`Select providers (comma separated):\n${list}\n> `);
+  return selectProviders(answer);
+};
+
+export const resolveCodexSkillsRoot = (startDir: string) => {
+  const resolvedStart = resolve(startDir);
+  const gitRoot = resolveGitRoot(resolvedStart);
+
+  if (!gitRoot) {
+    return join(resolvedStart, ".codex", "skills");
+  }
+
+  const localCodexRoot = join(gitRoot, ".codex");
+  if (isDirectory(localCodexRoot)) {
+    return join(localCodexRoot, "skills");
+  }
+
+  const home = process.env.HOME ?? homedir();
+  return join(home, ".codex", "skills");
+};
+
+export const installCodexSkills = (destination: string) => {
+  mkdirSync(destination, { recursive: true });
+
+  const entries = readdirSync(BUNDLED_SKILLS_ROOT, { withFileTypes: true });
+  const installed: string[] = [];
+  const skipped: string[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const source = join(BUNDLED_SKILLS_ROOT, entry.name);
+    const target = join(destination, entry.name);
+
+    if (existsSync(target)) {
+      skipped.push(entry.name);
+      continue;
+    }
+
+    cpSync(source, target, { recursive: true });
+    installed.push(entry.name);
+  }
+
+  return { installed, skipped };
+};
+
+const reportCodexInstall = (destination: string, installed: string[], skipped: string[]) => {
+  process.stdout.write(`[OK] Codex skills: ${destination}\n`);
+
+  for (const skill of installed) {
+    process.stdout.write(`[OK] Installed ${skill}\n`);
+  }
+
+  for (const skill of skipped) {
+    process.stdout.write(`[SKIP] ${skill}\n`);
+  }
+};
+
+const parseInitOptions = (args: string[]) => {
+  if (args.length === 0) {
+    return;
+  }
+
+  throw new Error(`Unknown option(s): ${args.join(", ")}`);
+};
+
+export const runInit = async (args: string[], startDir: string) => {
+  parseInitOptions(args);
+
+  const schubRoot = initSchubRoot(startDir);
+  process.stdout.write(`[OK] Wrote ${schubRoot}\n`);
+
+  const providers = await promptForProviders();
+  if (providers.includes("codex")) {
+    const destination = resolveCodexSkillsRoot(startDir);
+    const { installed, skipped } = installCodexSkills(destination);
+    reportCodexInstall(destination, installed, skipped);
+  }
+};

package/src/commands/project.test.ts

@@ -0,0 +1,113 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const templateRoot = join(cliDir, "templates", "setup-project");
+const decoder = new TextDecoder();
+
+const runProjectCreate = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "project", "create", ...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 = (name = "repo") => {
+  const base = mkdtempSync(join(tmpdir(), "schub-project-"));
+  const repoRoot = join(base, name);
+  const cwd = join(repoRoot, "nested", "dir");
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(cwd, { recursive: true });
+  mkdirSync(schubRoot, { recursive: true });
+  return { repoRoot, cwd, schubRoot };
+};
+
+test("project create scaffolds docs with derived project name", () => {
+  const { cwd, schubRoot } = createRepo();
+  const { result } = runProjectCreate(cwd);
+
+  expect(result.exitCode).toBe(0);
+
+  const overviewPath = join(schubRoot, "project-overview.md");
+  const setupPath = join(schubRoot, "project-setup.md");
+  const wowPath = join(schubRoot, "project-wow.md");
+
+  expect(existsSync(overviewPath)).toBe(true);
+  expect(existsSync(setupPath)).toBe(true);
+  expect(existsSync(wowPath)).toBe(true);
+
+  const overview = readFileSync(overviewPath, "utf8");
+  const setup = readFileSync(setupPath, "utf8");
+  const wow = readFileSync(wowPath, "utf8");
+  const projectName = "repo";
+  const overviewTemplate = readFileSync(join(templateRoot, "project-overview-template.md"), "utf8");
+  const setupTemplate = readFileSync(join(templateRoot, "project-setup-template.md"), "utf8");
+  const wowTemplate = readFileSync(join(templateRoot, "project-wow-template.md"), "utf8");
+
+  expect(overview).toBe(overviewTemplate.split("[Project Name]").join(projectName));
+  expect(setup).toBe(setupTemplate.split("[Project Name]").join(projectName));
+  expect(wow).toBe(wowTemplate.split("[Project Name]").join(projectName));
+});
+
+test("project create supports --project-name", () => {
+  const { cwd, schubRoot } = createRepo();
+  const { result } = runProjectCreate(cwd, ["--project-name", "Acme"]);
+
+  expect(result.exitCode).toBe(0);
+  const overview = readFileSync(join(schubRoot, "project-overview.md"), "utf8");
+  expect(overview).toContain("# Acme - Overview");
+});
+
+test("project create derives project name from --repo-root", () => {
+  const { cwd, schubRoot } = createRepo();
+  const base = dirname(dirname(cwd));
+  const altRoot = join(base, "alt-project");
+  mkdirSync(altRoot, { recursive: true });
+
+  const { result } = runProjectCreate(cwd, ["--repo-root", altRoot]);
+
+  expect(result.exitCode).toBe(0);
+  const overview = readFileSync(join(schubRoot, "project-overview.md"), "utf8");
+  expect(overview).toContain("# alt-project - Overview");
+});
+
+test("project create respects overwrite", () => {
+  const { cwd, schubRoot } = createRepo();
+  const overviewPath = join(schubRoot, "project-overview.md");
+
+  const first = runProjectCreate(cwd, ["--project-name", "First"]);
+  expect(first.result.exitCode).toBe(0);
+  expect(readFileSync(overviewPath, "utf8")).toContain("# First - Overview");
+
+  const second = runProjectCreate(cwd, ["--project-name", "Second"]);
+  expect(second.result.exitCode).not.toBe(0);
+  expect(second.stderr).toContain("Refusing to overwrite");
+  expect(readFileSync(overviewPath, "utf8")).toContain("# First - Overview");
+
+  const third = runProjectCreate(cwd, ["--project-name", "Second", "--overwrite"]);
+  expect(third.result.exitCode).toBe(0);
+  expect(readFileSync(overviewPath, "utf8")).toContain("# Second - Overview");
+});
+
+test("project create rejects schub root flags", () => {
+  const { cwd } = createRepo();
+  const schubRoot = runProjectCreate(cwd, ["--schub-root", "/tmp"]);
+  expect(schubRoot.result.exitCode).not.toBe(0);
+  expect(schubRoot.stderr).toContain("Unsupported option: --schub-root.");
+
+  const agentRoot = runProjectCreate(cwd, ["--agent-root", "/tmp"]);
+  expect(agentRoot.result.exitCode).not.toBe(0);
+  expect(agentRoot.stderr).toContain("Unsupported option: --agent-root.");
+});

package/src/commands/project.ts

@@ -0,0 +1,75 @@
+import { createProject } from "../project";
+
+type ProjectCreateOptions = {
+  repoRoot?: string;
+  projectName?: string;
+  overwrite: boolean;
+};
+
+const parseProjectCreateOptions = (args: string[]) => {
+  let repoRoot: string | undefined;
+  let projectName: string | undefined;
+  let overwrite = false;
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--overwrite") {
+      overwrite = true;
+      continue;
+    }
+    if (arg === "--repo-root") {
+      repoRoot = args[index + 1];
+      if (repoRoot === undefined) {
+        throw new Error("Missing value for --repo-root.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--repo-root=")) {
+      repoRoot = arg.slice("--repo-root=".length);
+      continue;
+    }
+    if (arg === "--project-name") {
+      projectName = args[index + 1];
+      if (projectName === undefined) {
+        throw new Error("Missing value for --project-name.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--project-name=")) {
+      projectName = arg.slice("--project-name=".length);
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  return { repoRoot, projectName, overwrite };
+};
+
+export const runProjectCreate = (args: string[], startDir: string) => {
+  const options: ProjectCreateOptions = parseProjectCreateOptions(args);
+  const outputs = createProject(startDir, options);
+
+  for (const output of outputs) {
+    process.stdout.write(`[OK] Wrote ${output}\n`);
+  }
+};

package/src/commands/review.test.ts

@@ -0,0 +1,100 @@
+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 { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runCli = (schubCwd: string, args: string[]) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", ...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-review-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(cwd, { recursive: true });
+  mkdirSync(schubRoot, { recursive: true });
+  return { cwd, schubRoot };
+};
+
+const seedChange = (schubRoot: string, changeId: string, title: string) => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  const proposal = [
+    `# Proposal - ${title}`,
+    "",
+    `**Change ID**: \`${changeId}\``,
+    "**Created**: 2024-01-01",
+    "**Status**: Draft",
+    "",
+  ].join("\n");
+  writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
+};
+
+test("review create scaffolds REVIEW_ME from template", () => {
+  const { cwd, schubRoot } = createRepo();
+  const changeId = "C001_sample-change";
+  const changeTitle = "Sample Change";
+  seedChange(schubRoot, changeId, changeTitle);
+
+  const { result } = runCli(cwd, ["review", "create", "--change-id", changeId]);
+  expect(result.exitCode).toBe(0);
+
+  const reviewPath = join(schubRoot, "changes", changeId, "REVIEW_ME.md");
+  expect(existsSync(reviewPath)).toBe(true);
+
+  const templatePath = join(cliDir, "templates", "review-proposal", "review-me-template.md");
+  const template = readFileSync(templatePath, "utf8");
+  const today = new Date().toISOString().split("T")[0];
+  const expected = template
+    .replace("{{CHANGE_TITLE}}", changeTitle)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today);
+
+  expect(readFileSync(reviewPath, "utf8")).toBe(expected);
+});
+
+test("review complete creates Q&A with review content", () => {
+  const { cwd, schubRoot } = createRepo();
+  const changeId = "C002_review-complete";
+  const changeTitle = "Review Complete";
+  seedChange(schubRoot, changeId, changeTitle);
+
+  const reviewPath = join(schubRoot, "changes", changeId, "REVIEW_ME.md");
+  const reviewContent = ["## Open Questions", "- [ ] Q1: What is the plan?", ""].join("\n");
+  writeFileSync(reviewPath, reviewContent, "utf8");
+
+  const { result } = runCli(cwd, ["review", "complete", "--change-id", changeId]);
+  expect(result.exitCode).toBe(0);
+
+  const qnaPath = join(schubRoot, "changes", changeId, "Q&A.md");
+  expect(existsSync(qnaPath)).toBe(true);
+  expect(existsSync(reviewPath)).toBe(false);
+
+  const templatePath = join(cliDir, "templates", "review-proposal", "q&a-template.md");
+  const template = readFileSync(templatePath, "utf8");
+  const today = new Date().toISOString().split("T")[0];
+  const expected = template
+    .replace("{{CHANGE_TITLE}}", changeTitle)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today)
+    .replace("{{REVIEW_CONTENT}}", reviewContent);
+
+  expect(readFileSync(qnaPath, "utf8")).toBe(expected);
+});