gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/tests/worktree-post-create-hook.test.ts

@@ -1,165 +0,0 @@
-/**
- * worktree-post-create-hook.test.ts — Tests for #597 worktree post-create hook.
- *
- * Verifies that runWorktreePostCreateHook correctly executes user scripts
- * with SOURCE_DIR and WORKTREE_DIR environment variables.
- *
- * Uses Node.js scripts instead of bash for Windows compatibility.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync, readFileSync, chmodSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { runWorktreePostCreateHook } from "../auto-worktree.ts";
-
-function makeTmpDir(): string {
-  return mkdtempSync(join(tmpdir(), "gsd-wt-hook-test-"));
-}
-
-const isWin = process.platform === "win32";
-
-/** Return the platform-appropriate hook file path (adds .bat on Windows). */
-function hookPath(base: string): string {
-  return isWin ? `${base}.bat` : base;
-}
-
-/** Create a cross-platform Node.js hook script. */
-function writeNodeHookScript(filePath: string, code: string): void {
-  if (isWin) {
-    // Write the JS code to a companion .js file and have the .bat invoke it.
-    // node -e with multi-line code breaks on Windows because cmd.exe splits on newlines.
-    const jsPath = filePath.replace(/\.bat$/, ".js");
-    writeFileSync(jsPath, code);
-    writeFileSync(filePath, `@echo off\nnode "%~dp0${jsPath.split("\\").pop()}" %*\n`);
-  } else {
-    writeFileSync(filePath, `#!/usr/bin/env node\n${code}\n`);
-    chmodSync(filePath, 0o755);
-  }
-}
-
-// ─── runWorktreePostCreateHook ──────────────────────────────────────────────
-
-test("returns null when no hook path is provided", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const result = runWorktreePostCreateHook(src, wt, undefined);
-    assert.equal(result, null);
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("returns error when hook script does not exist", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const result = runWorktreePostCreateHook(src, wt, ".gsd/hooks/nonexistent");
-    assert.ok(result !== null, "should return error string");
-    assert.ok(result!.includes("not found"), "error should mention 'not found'");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("executes hook script with correct SOURCE_DIR and WORKTREE_DIR env vars", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hooksDir = join(src, ".gsd", "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    const hookFile = hookPath(join(hooksDir, "post-create"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `const out = path.join(process.env.WORKTREE_DIR, "hook-output.txt");`,
-      `fs.writeFileSync(out, "SOURCE=" + process.env.SOURCE_DIR + "\\n" + "WORKTREE=" + process.env.WORKTREE_DIR + "\\n");`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookPath(".gsd/hooks/post-create"));
-    assert.equal(result, null, "should succeed");
-
-    const outputFile = join(wt, "hook-output.txt");
-    assert.ok(existsSync(outputFile), "hook should have created output file");
-
-    const output = readFileSync(outputFile, "utf-8");
-    assert.ok(output.includes(`SOURCE=${src}`), "SOURCE_DIR should match source dir");
-    assert.ok(output.includes(`WORKTREE=${wt}`), "WORKTREE_DIR should match worktree dir");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("returns error message when hook script fails", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hooksDir = join(src, ".gsd", "hooks");
-    mkdirSync(hooksDir, { recursive: true });
-    const hookFile = hookPath(join(hooksDir, "failing-hook"));
-    writeNodeHookScript(hookFile, `process.exit(1);`);
-
-    const result = runWorktreePostCreateHook(src, wt, hookPath(".gsd/hooks/failing-hook"));
-    assert.ok(result !== null, "should return error string");
-    assert.ok(result!.includes("hook failed"), "error should mention 'hook failed'");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("supports absolute hook paths", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    const hookFile = hookPath(join(src, "absolute-hook"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `fs.writeFileSync(path.join(process.env.WORKTREE_DIR, "absolute-hook-ran"), "");`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookFile);
-    assert.equal(result, null, "absolute path hook should succeed");
-    assert.ok(existsSync(join(wt, "absolute-hook-ran")), "hook should have run");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});
-
-test("hook can copy files from source to worktree", () => {
-  const src = makeTmpDir();
-  const wt = makeTmpDir();
-  try {
-    writeFileSync(join(src, ".env"), "DB_HOST=localhost\nAPI_KEY=secret123\n");
-
-    const hookFile = hookPath(join(src, "setup-hook"));
-    const code = [
-      `const fs = require("fs");`,
-      `const path = require("path");`,
-      `const envSrc = path.join(process.env.SOURCE_DIR, ".env");`,
-      `const envDst = path.join(process.env.WORKTREE_DIR, ".env");`,
-      `fs.copyFileSync(envSrc, envDst);`,
-    ].join("\n");
-    writeNodeHookScript(hookFile, code);
-
-    const result = runWorktreePostCreateHook(src, wt, hookFile);
-    assert.equal(result, null, "hook should succeed");
-
-    assert.ok(existsSync(join(wt, ".env")), ".env should be copied to worktree");
-    const envContent = readFileSync(join(wt, ".env"), "utf-8");
-    assert.ok(envContent.includes("API_KEY=secret123"), ".env content should match");
-  } finally {
-    rmSync(src, { recursive: true, force: true });
-    rmSync(wt, { recursive: true, force: true });
-  }
-});

package/dist/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -1,206 +0,0 @@
-/**
- * worktree-sync-milestones.test.ts — Regression test for #1311.
- *
- * Verifies that syncGsdStateToWorktree copies missing milestones,
- * milestone files, and slice directories from the main repo's .gsd/
- * into the worktree's .gsd/.
- *
- * Covers:
- *   - Entirely missing milestone directory
- *   - Milestone exists but missing CONTEXT/ROADMAP files
- *   - Missing slices within an existing milestone
- *   - No-op when directories are identical (symlinked)
- *   - Root-level files (DECISIONS, REQUIREMENTS, etc.)
- */
-
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, symlinkSync, realpathSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { syncGsdStateToWorktree } from '../auto-worktree.ts';
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-function createBase(name: string): string {
-  const base = mkdtempSync(join(tmpdir(), `gsd-wt-sync-${name}-`));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-async function main(): Promise<void> {
-
-  // ─── 1. Missing milestone directory is synced ─────────────────────────
-  console.log('\n=== 1. missing milestone directory is copied from main ===');
-  {
-    const mainBase = createBase('main');
-    const wtBase = createBase('wt');
-
-    try {
-      // Main repo has M001 and M002
-      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(m001Dir, { recursive: true });
-      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
-      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
-
-      const m002Dir = join(mainBase, '.gsd', 'milestones', 'M002');
-      mkdirSync(m002Dir, { recursive: true });
-      writeFileSync(join(m002Dir, 'M002-CONTEXT.md'), '# M002\nNew milestone.');
-      writeFileSync(join(m002Dir, 'M002-ROADMAP.md'), '# Roadmap');
-
-      // Worktree only has M001
-      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(wtM001Dir, { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
-
-      // M002 is missing from worktree
-      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), 'M002 missing before sync');
-
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), '#1311: M002 synced to worktree');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-CONTEXT.md')), 'M002 CONTEXT synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-ROADMAP.md')), 'M002 ROADMAP synced');
-      assertTrue(result.synced.length > 0, 'sync reported files');
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
-
-  // ─── 2. Missing files within existing milestone ───────────────────────
-  console.log('\n=== 2. missing files within existing milestone are synced ===');
-  {
-    const mainBase = createBase('main');
-    const wtBase = createBase('wt');
-
-    try {
-      // Main repo M001 has CONTEXT, ROADMAP, RESEARCH
-      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(m001Dir, { recursive: true });
-      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001 Context');
-      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# M001 Roadmap');
-      writeFileSync(join(m001Dir, 'M001-RESEARCH.md'), '# M001 Research');
-
-      // Worktree M001 only has CONTEXT (stale snapshot)
-      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(wtM001Dir, { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001 Context');
-
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'ROADMAP synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-RESEARCH.md')), 'RESEARCH synced');
-      // Existing file should NOT be overwritten
-      assertEq(
-        readFileSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), 'utf-8'),
-        '# M001 Context',
-        'existing CONTEXT not overwritten',
-      );
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
-
-  // ─── 3. Missing slices directory synced ───────────────────────────────
-  console.log('\n=== 3. missing slices directory synced ===');
-  {
-    const mainBase = createBase('main');
-    const wtBase = createBase('wt');
-
-    try {
-      // Main repo has M001 with slices S01–S03
-      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
-      mkdirSync(join(m001Dir, 'slices', 'S02'), { recursive: true });
-      mkdirSync(join(m001Dir, 'slices', 'S03'), { recursive: true });
-      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
-      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
-      writeFileSync(join(m001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
-      writeFileSync(join(m001Dir, 'slices', 'S03', 'S03-PLAN.md'), '# S03 Plan');
-
-      // Worktree M001 has slices S01–S02 only (S03 missing)
-      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(join(wtM001Dir, 'slices', 'S01'), { recursive: true });
-      mkdirSync(join(wtM001Dir, 'slices', 'S02'), { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-ROADMAP.md'), '# Roadmap');
-      writeFileSync(join(wtM001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
-      writeFileSync(join(wtM001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
-
-      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), 'S03 missing before sync');
-
-      syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), '#1311: S03 synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03', 'S03-PLAN.md')), 'S03 PLAN synced');
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
-
-  // ─── 4. No-op when both resolve to same directory (symlink) ───────────
-  console.log('\n=== 4. no-op when .gsd/ resolves to same path (symlinked) ===');
-  {
-    const sharedDir = createBase('shared');
-    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-main-'));
-    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-wt-'));
-
-    try {
-      // Both main and worktree symlink to the same shared directory
-      writeFileSync(join(sharedDir, '.gsd', 'milestones', 'keep'), '');
-      symlinkSync(join(sharedDir, '.gsd'), join(mainBase, '.gsd'));
-      symlinkSync(join(sharedDir, '.gsd'), join(wtBase, '.gsd'));
-
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-      assertEq(result.synced.length, 0, 'no files synced when both point to same dir');
-    } finally {
-      cleanup(sharedDir);
-      rmSync(mainBase, { recursive: true, force: true });
-      rmSync(wtBase, { recursive: true, force: true });
-    }
-  }
-
-  // ─── 5. Root-level .gsd/ files synced ─────────────────────────────────
-  console.log('\n=== 5. root-level .gsd/ files synced ===');
-  {
-    const mainBase = createBase('main');
-    const wtBase = createBase('wt');
-
-    try {
-      writeFileSync(join(mainBase, '.gsd', 'DECISIONS.md'), '# Decisions');
-      writeFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements');
-      writeFileSync(join(mainBase, '.gsd', 'PROJECT.md'), '# Project');
-
-      // Worktree has none of these
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'DECISIONS.md')), 'DECISIONS.md synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'REQUIREMENTS.md')), 'REQUIREMENTS.md synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'PROJECT.md')), 'PROJECT.md synced');
-      assertTrue(result.synced.length >= 3, 'at least 3 files synced');
-    } finally {
-      cleanup(mainBase);
-      cleanup(wtBase);
-    }
-  }
-
-  // ─── 6. Non-existent directories handled gracefully ───────────────────
-  console.log('\n=== 6. non-existent directories → no-op ===');
-  {
-    const result = syncGsdStateToWorktree('/tmp/does-not-exist-main', '/tmp/does-not-exist-wt');
-    assertEq(result.synced.length, 0, 'no crash on missing directories');
-  }
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});

package/dist/resources/extensions/gsd/tests/worktree.test.ts

@@ -1,171 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import {
-  autoCommitCurrentBranch,
-  captureIntegrationBranch,
-  detectWorktreeName,
-  getCurrentBranch,
-  getMainBranch,
-  getSliceBranchName,
-  parseSliceBranch,
-  setActiveMilestoneId,
-  SLICE_BRANCH_RE,
-} from "../worktree.ts";
-import { readIntegrationBranch } from "../git-service.ts";
-import { _resetHasChangesCache } from "../native-git-bridge.ts";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-const base = mkdtempSync(join(tmpdir(), "gsd-branch-test-"));
-run("git init -b main", base);
-run('git config user.name "Pi Test"', base);
-run('git config user.email "pi@example.com"', base);
-mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-writeFileSync(join(base, "README.md"), "hello\n", "utf-8");
-writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), `# M001: Demo\n\n## Slices\n- [ ] **S01: Slice One** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`, "utf-8");
-writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Slice One\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  do it\n`, "utf-8");
-run("git add .", base);
-run('git commit -m "chore: init"', base);
-
-async function main(): Promise<void> {
-
-  console.log("\n=== autoCommitCurrentBranch ===");
-  // Clean — should return null
-  const cleanResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
-  assertEq(cleanResult, null, "returns null for clean repo");
-
-  // Make dirty — reset the nativeHasChanges cache so the fresh dirt is detected
-  _resetHasChangesCache();
-  writeFileSync(join(base, "dirty.txt"), "uncommitted\n", "utf-8");
-  const dirtyResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
-  assertTrue(dirtyResult !== null, "returns commit message for dirty repo");
-  assertTrue(dirtyResult!.includes("M001/S01/T01"), "commit message includes unit id");
-  assertEq(run("git status --short", base), "", "repo is clean after auto-commit");
-
-  console.log("\n=== getSliceBranchName ===");
-  assertEq(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "branch name format correct");
-  assertEq(getSliceBranchName("M001", "S01", null), "gsd/M001/S01", "null worktree = plain branch");
-  assertEq(getSliceBranchName("M001", "S01", "my-wt"), "gsd/my-wt/M001/S01", "worktree-namespaced branch");
-
-  console.log("\n=== parseSliceBranch ===");
-  const plain = parseSliceBranch("gsd/M001/S01");
-  assertTrue(plain !== null, "parses plain branch");
-  assertEq(plain!.worktreeName, null, "plain branch has no worktree name");
-  assertEq(plain!.milestoneId, "M001", "plain branch milestone");
-  assertEq(plain!.sliceId, "S01", "plain branch slice");
-
-  const namespaced = parseSliceBranch("gsd/feature-auth/M001/S01");
-  assertTrue(namespaced !== null, "parses worktree-namespaced branch");
-  assertEq(namespaced!.worktreeName, "feature-auth", "worktree name extracted");
-  assertEq(namespaced!.milestoneId, "M001", "namespaced branch milestone");
-  assertEq(namespaced!.sliceId, "S01", "namespaced branch slice");
-
-  const invalid = parseSliceBranch("main");
-  assertEq(invalid, null, "non-slice branch returns null");
-
-  const worktreeBranch = parseSliceBranch("worktree/foo");
-  assertEq(worktreeBranch, null, "worktree/ prefix is not a slice branch");
-
-  console.log("\n=== SLICE_BRANCH_RE ===");
-  assertTrue(SLICE_BRANCH_RE.test("gsd/M001/S01"), "regex matches plain branch");
-  assertTrue(SLICE_BRANCH_RE.test("gsd/my-wt/M001/S01"), "regex matches worktree branch");
-  assertTrue(!SLICE_BRANCH_RE.test("main"), "regex rejects main");
-  assertTrue(!SLICE_BRANCH_RE.test("gsd/"), "regex rejects bare gsd/");
-  assertTrue(!SLICE_BRANCH_RE.test("worktree/foo"), "regex rejects worktree/foo");
-
-  console.log("\n=== detectWorktreeName ===");
-  assertEq(detectWorktreeName("/projects/myapp"), null, "no worktree in plain path");
-  assertEq(detectWorktreeName("/projects/myapp/.gsd/worktrees/feature-auth"), "feature-auth", "detects worktree name");
-  assertEq(detectWorktreeName("/projects/myapp/.gsd/worktrees/my-wt/subdir"), "my-wt", "detects worktree with subdir");
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // Integration branch — facade-level tests
-  // ═══════════════════════════════════════════════════════════════════════
-
-  // ── captureIntegrationBranch on a feature branch ──────────────────────
-
-  console.log("\n=== captureIntegrationBranch: records current branch ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-facade-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b f-123-thing", repo);
-    assertEq(getCurrentBranch(repo), "f-123-thing", "on feature branch");
-
-    captureIntegrationBranch(repo, "M001");
-    assertEq(readIntegrationBranch(repo, "M001"), "f-123-thing",
-      "captureIntegrationBranch records the current branch");
-
-    // .gsd/ metadata is written to disk only (not committed) since commit_docs removal
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  // ── captureIntegrationBranch skips slice branches ─────────────────────
-
-  console.log("\n=== captureIntegrationBranch: skips slice branches ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-skip-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b gsd/M001/S01", repo);
-    captureIntegrationBranch(repo, "M001");
-
-    assertEq(readIntegrationBranch(repo, "M001"), null,
-      "capture from slice branch is a no-op");
-
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  // ── setActiveMilestoneId makes getMainBranch return integration branch ─
-
-  console.log("\n=== setActiveMilestoneId + getMainBranch ===");
-
-  {
-    const repo = mkdtempSync(join(tmpdir(), "gsd-integ-main-"));
-    run("git init -b main", repo);
-    run("git config user.name 'Pi Test'", repo);
-    run("git config user.email 'pi@example.com'", repo);
-    writeFileSync(join(repo, "README.md"), "init\n");
-    run("git add -A && git commit -m init", repo);
-
-    run("git checkout -b my-feature", repo);
-    captureIntegrationBranch(repo, "M001");
-
-    // Without milestone set, getMainBranch returns "main"
-    setActiveMilestoneId(repo, null);
-    assertEq(getMainBranch(repo), "main",
-      "getMainBranch returns main without milestone set");
-
-    // With milestone set, getMainBranch returns feature branch
-    setActiveMilestoneId(repo, "M001");
-    assertEq(getMainBranch(repo), "my-feature",
-      "getMainBranch returns integration branch with milestone set");
-
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  rmSync(base, { recursive: true, force: true });
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});