gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

package/dist/resources/extensions/gsd/tests/activity-log.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Activity log tests — consolidated from:
+ *   - activity-log-prune.test.ts (age-based pruning with highest-seq preservation)
+ *   - activity-log-save.test.ts (caching, dedup, collision recovery)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, rmSync, utimesSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { pruneActivityLogs, saveActivityLog } from "../activity-log.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-activity-test-"));
+}
+
+function writeActivityFile(dir: string, seq: string, name: string): string {
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, `${seq}-${name}.jsonl`);
+  writeFileSync(filePath, `{"seq":${parseInt(seq, 10)},"name":"${name}"}\n`, "utf-8");
+  return filePath;
+}
+
+function backdateFile(filePath: string, daysAgo: number): void {
+  const pastMs = Date.now() - daysAgo * 24 * 60 * 60 * 1000;
+  const pastDate = new Date(pastMs);
+  utimesSync(filePath, pastDate, pastDate);
+}
+
+function listFiles(dir: string): string[] {
+  return existsSync(dir) ? readdirSync(dir).sort() : [];
+}
+
+function activityDir(baseDir: string): string {
+  return join(baseDir, ".gsd", "activity");
+}
+
+function createCtx(entries: unknown[]) {
+  return { sessionManager: { getEntries: () => entries } };
+}
+
+// ── Pruning ──────────────────────────────────────────────────────────────────
+
+test("pruneActivityLogs deletes old files, keeps recent and highest-seq", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "execute-task-M001-S01-T01");
+    writeActivityFile(dir, "002", "execute-task-M001-S01-T02");
+    writeActivityFile(dir, "003", "execute-task-M001-S01-T03");
+    backdateFile(f001, 40);
+
+    pruneActivityLogs(dir, 30);
+    const remaining = listFiles(dir);
+    assert.ok(!remaining.includes("001-execute-task-M001-S01-T01.jsonl"));
+    assert.ok(remaining.includes("002-execute-task-M001-S01-T02.jsonl"));
+    assert.ok(remaining.includes("003-execute-task-M001-S01-T03.jsonl"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs preserves highest-seq even when all files are old", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "t1");
+    const f002 = writeActivityFile(dir, "002", "t2");
+    const f003 = writeActivityFile(dir, "003", "t3");
+    backdateFile(f001, 40); backdateFile(f002, 40); backdateFile(f003, 40);
+
+    pruneActivityLogs(dir, 30);
+    const remaining = listFiles(dir);
+    assert.equal(remaining.length, 1);
+    assert.ok(remaining[0].startsWith("003-"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs with retentionDays=0 keeps only highest-seq", () => {
+  const dir = createTmpDir();
+  try {
+    writeActivityFile(dir, "001", "t1");
+    writeActivityFile(dir, "002", "t2");
+    writeActivityFile(dir, "003", "t3");
+
+    pruneActivityLogs(dir, 0);
+    const remaining = listFiles(dir);
+    assert.equal(remaining.length, 1);
+    assert.ok(remaining[0].startsWith("003-"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs no-op when all files are recent", () => {
+  const dir = createTmpDir();
+  try {
+    writeActivityFile(dir, "001", "t1");
+    writeActivityFile(dir, "002", "t2");
+    writeActivityFile(dir, "003", "t3");
+
+    pruneActivityLogs(dir, 30);
+    assert.equal(listFiles(dir).length, 3);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs handles empty directory", () => {
+  const dir = createTmpDir();
+  try {
+    assert.doesNotThrow(() => pruneActivityLogs(dir, 30));
+    assert.equal(readdirSync(dir).length, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs preserves single old file (it is highest-seq)", () => {
+  const dir = createTmpDir();
+  try {
+    const f = writeActivityFile(dir, "001", "t1");
+    backdateFile(f, 100);
+
+    pruneActivityLogs(dir, 30);
+    assert.equal(listFiles(dir).length, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pruneActivityLogs ignores non-matching filenames", () => {
+  const dir = createTmpDir();
+  try {
+    const f001 = writeActivityFile(dir, "001", "t1");
+    writeFileSync(join(dir, "notes.txt"), "some notes\n", "utf-8");
+    backdateFile(f001, 40);
+
+    assert.doesNotThrow(() => pruneActivityLogs(dir, 30));
+    const remaining = listFiles(dir);
+    assert.ok(remaining.includes("notes.txt"));
+    // 001 is the only seq file, so it's highest-seq and survives
+    assert.ok(remaining.includes("001-t1.jsonl"));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── Save: caching, dedup, collision recovery ─────────────────────────────────
+
+test("saveActivityLog caches sequence instead of rescanning", () => {
+  const baseDir = createTmpDir();
+  try {
+    saveActivityLog(createCtx([{ kind: "first", n: 1 }]) as any, baseDir, "execute-task", "M001/S01/T01");
+    writeFileSync(join(activityDir(baseDir), "999-external.jsonl"), '{"x":1}\n', "utf-8");
+    saveActivityLog(createCtx([{ kind: "second", n: 2 }]) as any, baseDir, "execute-task", "M001/S01/T02");
+
+    const files = listFiles(activityDir(baseDir));
+    assert.ok(files.includes("001-execute-task-M001-S01-T01.jsonl"));
+    assert.ok(files.includes("002-execute-task-M001-S01-T02.jsonl"));
+    assert.ok(!files.some(f => f.startsWith("1000-")));
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("saveActivityLog deduplicates identical snapshots for same unit", () => {
+  const baseDir = createTmpDir();
+  try {
+    const ctx = createCtx([{ role: "assistant", content: "same" }]);
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+
+    let files = listFiles(activityDir(baseDir));
+    assert.equal(files.length, 1);
+
+    saveActivityLog(createCtx([{ role: "assistant", content: "changed" }]) as any, baseDir, "plan-slice", "M002/S01");
+    files = listFiles(activityDir(baseDir));
+    assert.equal(files.length, 2);
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("saveActivityLog recovers on sequence collision", () => {
+  const baseDir = createTmpDir();
+  try {
+    saveActivityLog(createCtx([{ turn: 1 }]) as any, baseDir, "execute-task", "M003/S02/T01");
+    writeFileSync(join(activityDir(baseDir), "002-execute-task-M003-S02-T02.jsonl"), '{"collision":true}\n', "utf-8");
+    saveActivityLog(createCtx([{ turn: 2 }]) as any, baseDir, "execute-task", "M003/S02/T02");
+
+    const files = listFiles(activityDir(baseDir));
+    assert.ok(files.includes("002-execute-task-M003-S02-T02.jsonl"));
+    assert.ok(files.includes("003-execute-task-M003-S02-T02.jsonl"));
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ── Prompt text assertion ────────────────────────────────────────────────────
+
+test("complete-slice.md contains refresh state instruction", () => {
+  const promptPath = join(__dirname, "..", "prompts", "complete-slice.md");
+  const content = readFileSync(promptPath, "utf-8");
+  assert.ok(content.includes("refresh current state if needed"));
+});

package/dist/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -0,0 +1,107 @@
+/**
+ * agent-end-retry.test.ts — Verifies the deferred agent_end retry mechanism (#1072).
+ *
+ * When handleAgentEnd is already running and a second agent_end event fires
+ * (e.g. a hook/triage/quick-task unit dispatched inside handleAgentEnd completes
+ * before it returns), the reentrancy guard must not silently drop the event.
+ * Instead, it should queue a retry via pendingAgentEndRetry so the completed
+ * unit's agent_end is processed after the current handler finishes.
+ *
+ * Without this, auto-mode can stall permanently in the "summarizing" phase
+ * with no unit running and no watchdog set.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+
+function getAutoTsSource(): string {
+  return readFileSync(AUTO_TS_PATH, "utf-8");
+}
+
+function getSessionTsSource(): string {
+  return readFileSync(SESSION_TS_PATH, "utf-8");
+}
+
+// ── AutoSession must declare pendingAgentEndRetry ────────────────────────────
+
+test("AutoSession declares pendingAgentEndRetry field", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("pendingAgentEndRetry"),
+    "AutoSession (auto/session.ts) must declare pendingAgentEndRetry field for deferred retry",
+  );
+});
+
+test("AutoSession resets pendingAgentEndRetry in reset()", () => {
+  const source = getSessionTsSource();
+  // Find the reset() method — it's declared as "reset(): void {"
+  const resetIdx = source.indexOf("reset(): void");
+  assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
+  const resetBlock = source.slice(resetIdx, resetIdx + 3000);
+  assert.ok(
+    resetBlock.includes("pendingAgentEndRetry"),
+    "reset() must clear pendingAgentEndRetry",
+  );
+});
+
+// ── handleAgentEnd reentrancy guard must queue retry ─────────────────────────
+
+test("handleAgentEnd sets pendingAgentEndRetry when reentrant", () => {
+  const source = getAutoTsSource();
+  // Find the handleAgentEnd function
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  assert.ok(fnIdx > -1, "handleAgentEnd must exist in auto.ts");
+
+  // The reentrancy guard section (within ~500 chars of the function start)
+  const guardBlock = source.slice(fnIdx, fnIdx + 800);
+  assert.ok(
+    guardBlock.includes("s.handlingAgentEnd"),
+    "handleAgentEnd must check s.handlingAgentEnd",
+  );
+  assert.ok(
+    guardBlock.includes("pendingAgentEndRetry = true"),
+    "reentrancy guard must set pendingAgentEndRetry = true instead of silently dropping (#1072)",
+  );
+});
+
+// ── finally block must process pendingAgentEndRetry ──────────────────────────
+
+test("handleAgentEnd finally block retries if pendingAgentEndRetry is set", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  assert.ok(fnIdx > -1, "handleAgentEnd must exist");
+
+  // Find the finally block within handleAgentEnd (search for the closing pattern)
+  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── ", fnIdx + 100));
+  assert.ok(
+    fnBlock.includes("pendingAgentEndRetry"),
+    "handleAgentEnd finally block must check pendingAgentEndRetry",
+  );
+  assert.ok(
+    fnBlock.includes("setImmediate"),
+    "deferred retry must use setImmediate to avoid stack overflow (#1072)",
+  );
+  assert.ok(
+    fnBlock.includes("handleAgentEnd(ctx, pi)"),
+    "deferred retry must call handleAgentEnd recursively (#1072)",
+  );
+});
+
+// ── Regression: reentrancy guard must NOT silently return ─────────────────────
+
+test("reentrancy guard references issue #1072", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  const guardBlock = source.slice(fnIdx, fnIdx + 800);
+  assert.ok(
+    guardBlock.includes("1072"),
+    "reentrancy guard comment must reference #1072 for traceability",
+  );
+});

package/dist/resources/extensions/gsd/tests/all-milestones-complete-merge.test.ts

@@ -0,0 +1,197 @@
+/**
+ * all-milestones-complete-merge.test.ts — Tests for #962 fix.
+ *
+ * Verifies that when the final milestone completes and there are no queued
+ * follow-up milestones, the worktree is squash-merged to main before
+ * stopAuto() tears it down. Without this fix, all work stays on the
+ * milestone branch, unmerged to main.
+ *
+ * Uses both source-level checks (verifying the code path exists in auto.ts)
+ * and real git integration tests (verifying merge behavior).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import {
+  createAutoWorktree,
+  isInAutoWorktree,
+  getAutoWorktreeOriginalBase,
+  mergeMilestoneToMain,
+} from "../auto-worktree.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-all-complete-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
+  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+function createMilestoneArtifacts(dir: string, mid: string): void {
+  const msDir = join(dir, ".gsd", "milestones", mid);
+  mkdirSync(msDir, { recursive: true });
+  writeFileSync(join(msDir, "CONTEXT.md"), `# ${mid} Context\n`);
+  const roadmap = [
+    `# ${mid}: Test Milestone`,
+    "**Vision**: testing",
+    "## Success Criteria",
+    "- It works",
+    "## Slices",
+    "- [x] S01 — First slice",
+  ].join("\n");
+  writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
+}
+
+// ─── Source-level: verify the merge code exists in the "all complete" path ────
+
+test("auto.ts 'all milestones complete' path merges before stopping (#962)", () => {
+  const autoSrc = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+
+  // Find the "incomplete.length === 0" block
+  const incompleteIdx = autoSrc.indexOf("incomplete.length === 0");
+  assert.ok(incompleteIdx > -1, "auto.ts should have 'incomplete.length === 0' check");
+
+  // The merge call must appear BETWEEN the incomplete check and the stopAuto call
+  // in that same block
+  const blockAfterIncomplete = autoSrc.slice(incompleteIdx, incompleteIdx + 3000);
+
+  assert.ok(
+    blockAfterIncomplete.includes("mergeMilestoneToMain"),
+    "auto.ts should call mergeMilestoneToMain in the 'all milestones complete' path",
+  );
+
+  // The merge should come before stopAuto in this block
+  const mergePos = blockAfterIncomplete.indexOf("mergeMilestoneToMain");
+  const stopPos = blockAfterIncomplete.indexOf("stopAuto");
+  assert.ok(
+    mergePos < stopPos,
+    "mergeMilestoneToMain should be called before stopAuto in the 'all complete' path",
+  );
+
+  // Should handle both worktree and branch isolation modes
+  assert.ok(
+    blockAfterIncomplete.includes("isInAutoWorktree"),
+    "should check isInAutoWorktree for worktree mode",
+  );
+  assert.ok(
+    blockAfterIncomplete.includes("getIsolationMode"),
+    "should check getIsolationMode for branch isolation mode",
+  );
+});
+
+// ─── Integration: single milestone completes → merged to main ────────────────
+
+test("single milestone worktree is merged to main when all complete (#962)", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Set up a single milestone
+    createMilestoneArtifacts(tempDir, "M001");
+    run("git add .", tempDir);
+    run('git commit -m "add milestone"', tempDir);
+
+    // Create worktree and simulate work
+    const wt = createAutoWorktree(tempDir, "M001");
+    assert.ok(isInAutoWorktree(tempDir), "should be in auto-worktree");
+
+    writeFileSync(join(wt, "feature.ts"), "export const feature = true;\n");
+    run("git add .", wt);
+    run('git commit -m "feat(M001): add feature"', wt);
+
+    // Simulate the fix: merge before stopping (what the "all complete" path now does)
+    const roadmapPath = join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmapContent = readFileSync(roadmapPath, "utf-8");
+    const mergeResult = mergeMilestoneToMain(tempDir, "M001", roadmapContent);
+
+    // Verify work is on main
+    assert.ok(existsSync(join(tempDir, "feature.ts")), "feature.ts should be on main after merge");
+    assert.equal(process.cwd(), tempDir, "cwd restored to project root");
+    assert.ok(!isInAutoWorktree(tempDir), "no longer in auto-worktree");
+    assert.equal(getAutoWorktreeOriginalBase(), null, "originalBase cleared");
+
+    // Verify milestone branch was cleaned up
+    const branches = run("git branch", tempDir);
+    assert.ok(!branches.includes("milestone/M001"), "milestone branch should be deleted");
+
+    // Verify squash commit on main
+    const log = run("git log --oneline -3", tempDir);
+    assert.ok(log.includes("M001"), "squash commit on main should reference M001");
+
+    assert.ok(mergeResult.commitMessage.length > 0, "commit message returned");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});
+
+// ─── Integration: last of multiple milestones completes → merged ─────────────
+
+test("last milestone worktree is merged when it's the final one (#962)", () => {
+  const savedCwd = process.cwd();
+  let tempDir = "";
+
+  try {
+    tempDir = createTempRepo();
+
+    // Set up two milestones
+    createMilestoneArtifacts(tempDir, "M001");
+    createMilestoneArtifacts(tempDir, "M002");
+    run("git add .", tempDir);
+    run('git commit -m "add milestones"', tempDir);
+
+    // Complete M001 first (merge it)
+    const wt1 = createAutoWorktree(tempDir, "M001");
+    writeFileSync(join(wt1, "m001-work.ts"), "export const m001 = true;\n");
+    run("git add .", wt1);
+    run('git commit -m "feat(M001): m001 work"', wt1);
+    const roadmap1 = readFileSync(join(tempDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf-8");
+    mergeMilestoneToMain(tempDir, "M001", roadmap1);
+
+    // Now complete M002 (the LAST milestone — this is the #962 scenario)
+    const wt2 = createAutoWorktree(tempDir, "M002");
+    writeFileSync(join(wt2, "m002-work.ts"), "export const m002 = true;\n");
+    run("git add .", wt2);
+    run('git commit -m "feat(M002): m002 work"', wt2);
+    const roadmap2 = readFileSync(join(tempDir, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "utf-8");
+    mergeMilestoneToMain(tempDir, "M002", roadmap2);
+
+    // Both features should now be on main
+    assert.ok(existsSync(join(tempDir, "m001-work.ts")), "M001 work on main");
+    assert.ok(existsSync(join(tempDir, "m002-work.ts")), "M002 work on main");
+    assert.ok(!isInAutoWorktree(tempDir), "not in worktree after final merge");
+
+    // Both milestone branches should be cleaned up
+    const branches = run("git branch", tempDir);
+    assert.ok(!branches.includes("milestone/M001"), "M001 branch deleted");
+    assert.ok(!branches.includes("milestone/M002"), "M002 branch deleted");
+  } finally {
+    process.chdir(savedCwd);
+    if (tempDir && existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+});

package/dist/resources/extensions/gsd/tests/auto-dashboard.test.ts

@@ -7,6 +7,7 @@ import {
   describeNextUnit,
   formatAutoElapsed,
   formatWidgetTokens,
+  estimateTimeRemaining,
 } from "../auto-dashboard.ts";
 
 // ─── unitVerb ─────────────────────────────────────────────────────────────
@@ -151,3 +152,15 @@ test("formatWidgetTokens formats millions with M", () => {
   assert.equal(formatWidgetTokens(10_000_000), "10M");
   assert.equal(formatWidgetTokens(25_000_000), "25M");
 });
+
+// ─── estimateTimeRemaining ──────────────────────────────────────────────
+
+test("estimateTimeRemaining returns null when no ledger data", () => {
+  // With no active auto-mode session, ledger is empty
+  const result = estimateTimeRemaining();
+  assert.equal(result, null);
+});
+
+test("estimateTimeRemaining is exported and callable", () => {
+  assert.equal(typeof estimateTimeRemaining, "function");
+});

package/dist/resources/extensions/gsd/tests/auto-preflight.test.ts

@@ -1,46 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runGSDDoctor, selectDoctorScope, filterDoctorIssues } from "../doctor.js";
-import { createTestContext } from './test-helpers.ts';
 
-const { assertTrue, report } = createTestContext();
-const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));
-const gsd = join(tmpBase, ".gsd");
-
-mkdirSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-mkdirSync(join(gsd, "milestones", "M009", "slices", "S01", "tasks"), { recursive: true });
-
-writeFileSync(join(gsd, "milestones", "M001", "M001-ROADMAP.md"), `# M001: Historical\n\n## Slices\n- [x] **S01: Old Slice** \`risk:low\` \`depends:[]\`\n  > After this: old done\n`);
-writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Old Slice\n\n**Goal:** Old\n**Demo:** Old\n\n## Must-Haves\n- done\n\n## Tasks\n- [x] **T01: Old Task** \`est:5m\`\n  done\n`);
-writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# T01: Old Task\n\n**Done**\n\n## What Happened\nDone.\n\n## Diagnostics\n- log\n`);
-writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), `---\nid: S01\nparent: M001\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# S01: Old Slice\n\n**Done**\n\n## What Happened\nDone.\n\n## Verification\nDone.\n\n## Deviations\nNone\n\n## Known Limitations\nNone\n\n## Follow-ups\nNone\n\n## Files Created/Modified\n- \`x\` — x\n\n## Forward Intelligence\n\n### What the next slice should know\n- x\n\n### What's fragile\n- x\n\n### Authoritative diagnostics\n- x\n\n### What assumptions changed\n- x\n`);
-
-writeFileSync(join(gsd, "milestones", "M001", "M001-VALIDATION.md"), `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.\n`);
-writeFileSync(join(gsd, "milestones", "M001", "M001-SUMMARY.md"), `---\nid: M001\nstatus: complete\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# M001: Historical\n\nComplete.\n`);
-
-writeFileSync(join(gsd, "milestones", "M009", "M009-ROADMAP.md"), `# M009: Active\n\n## Slices\n- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`\n  > After this: active works\n`);
-writeFileSync(join(gsd, "milestones", "M009", "slices", "S01", "S01-PLAN.md"), `# S01: Active Slice\n\n**Goal:** Active\n**Demo:** Active\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Active Task** \`est:5m\`\n  todo\n`);
-
-async function main(): Promise<void> {
-  const scope = await selectDoctorScope(tmpBase);
-  assertTrue(scope === "M009/S01", "active scope selected instead of historical milestone");
-
-  const scopedReport = await runGSDDoctor(tmpBase, { fix: false, scope });
-  const scopedBlocking = filterDoctorIssues(scopedReport.issues, { scope, includeWarnings: false });
-  assertTrue(scopedBlocking.length === 0, "no blocking issues in active scope");
-
-  const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
-  const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
-  assertTrue(historicalWarnings.length > 0, "full repo still contains historical warning drift");
-
-  rmSync(tmpBase, { recursive: true, force: true });
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+test("auto-preflight scopes to active milestone, ignoring historical", async () => {
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));
+  const gsd = join(tmpBase, ".gsd");
+
+  mkdirSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(gsd, "milestones", "M009", "slices", "S01", "tasks"), { recursive: true });
+
+  writeFileSync(join(gsd, "milestones", "M001", "M001-ROADMAP.md"), `# M001: Historical\n\n## Slices\n- [x] **S01: Old Slice** \`risk:low\` \`depends:[]\`\n  > After this: old done\n`);
+  writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `# S01: Old Slice\n\n**Goal:** Old\n**Demo:** Old\n\n## Must-Haves\n- done\n\n## Tasks\n- [x] **T01: Old Task** \`est:5m\`\n  done\n`);
+  writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# T01: Old Task\n\n**Done**\n\n## What Happened\nDone.\n\n## Diagnostics\n- log\n`);
+  writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), `---\nid: S01\nparent: M001\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# S01: Old Slice\n\n**Done**\n\n## What Happened\nDone.\n\n## Verification\nDone.\n\n## Deviations\nNone\n\n## Known Limitations\nNone\n\n## Follow-ups\nNone\n\n## Files Created/Modified\n- \`x\` — x\n\n## Forward Intelligence\n\n### What the next slice should know\n- x\n\n### What's fragile\n- x\n\n### Authoritative diagnostics\n- x\n\n### What assumptions changed\n- x\n`);
+  writeFileSync(join(gsd, "milestones", "M001", "M001-VALIDATION.md"), `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.\n`);
+  writeFileSync(join(gsd, "milestones", "M001", "M001-SUMMARY.md"), `---\nid: M001\nstatus: complete\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# M001: Historical\n\nComplete.\n`);
+
+  writeFileSync(join(gsd, "milestones", "M009", "M009-ROADMAP.md"), `# M009: Active\n\n## Slices\n- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`\n  > After this: active works\n`);
+  writeFileSync(join(gsd, "milestones", "M009", "slices", "S01", "S01-PLAN.md"), `# S01: Active Slice\n\n**Goal:** Active\n**Demo:** Active\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Active Task** \`est:5m\`\n  todo\n`);
+
+  try {
+    const scope = await selectDoctorScope(tmpBase);
+    assert.equal(scope, "M009/S01", "active scope selected instead of historical milestone");
+
+    const scopedReport = await runGSDDoctor(tmpBase, { fix: false, scope });
+    const scopedBlocking = filterDoctorIssues(scopedReport.issues, { scope, includeWarnings: false });
+    assert.equal(scopedBlocking.length, 0, "no blocking issues in active scope");
+
+    const historicalReport = await runGSDDoctor(tmpBase, { fix: false });
+    const historicalWarnings = historicalReport.issues.filter(issue => issue.unitId.startsWith("M001/S01") && issue.severity === "warning");
+    assert.ok(historicalWarnings.length > 0, "full repo still contains historical warning drift");
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
 });