gsd-pi 2.28.0 → 2.29.0-dev.2ccf3fb

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-budget-alerts.test.ts

@@ -5,7 +5,7 @@ import {
   getBudgetAlertLevel,
   getBudgetEnforcementAction,
   getNewBudgetAlertLevel,
-} from "../auto.js";
+} from "../auto-budget.js";
 
 test("getBudgetAlertLevel returns the expected threshold bucket", () => {
   assert.equal(getBudgetAlertLevel(0.10), 0);

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 });
+  }
 });

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

@@ -2,10 +2,11 @@
  * Integration tests for the secrets collection gate in startAuto().
  *
  * Exercises getManifestStatus() → collectSecretsFromManifest() composition
- * end-to-end using real filesystem state. Proves the three gate paths:
+ * end-to-end using real filesystem state. Proves the gate paths:
  *   1. No manifest exists — gate skips silently
- *   2. Pending keys exist — gate triggers collection
+ *   2. Pending keys exist — gate triggers collection (direct call)
  *   3. No pending keys — gate skips silently
+ *   4. Pending keys in auto-mode — session pauses instead of blocking (#1146)
  *
  * Uses temp directories with real .gsd/milestones/M001/ structure, mirroring
  * the pattern from manifest-status.test.ts.
@@ -18,6 +19,7 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { getManifestStatus } from '../files.ts';
 import { collectSecretsFromManifest } from '../../get-secrets-from-user.ts';
+import { AutoSession } from '../auto/session.ts';
 
 function makeTempDir(prefix: string): string {
   const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -146,6 +148,110 @@ test('secrets gate: pending keys exist — gate triggers collection, manifest up
 
 // ─── Scenario 3: No pending keys — all collected or in env ──────────────────
 
+// ─── Scenario 4: Pending keys pause AutoSession instead of blocking (#1146) ──
+
+test('secrets gate: pending keys set pausedForSecrets on AutoSession', async () => {
+  const tmp = makeTempDir('gate-pause-session');
+  try {
+    // Ensure pending keys are NOT in env
+    delete process.env.GSD_PAUSE_TEST_KEY_A;
+    delete process.env.GSD_PAUSE_TEST_KEY_B;
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### GSD_PAUSE_TEST_KEY_A
+
+**Service:** ServiceA
+**Status:** pending
+**Destination:** dotenv
+
+1. Get key A from dashboard
+
+### GSD_PAUSE_TEST_KEY_B
+
+**Service:** ServiceB
+**Status:** pending
+**Destination:** dotenv
+
+1. Get key B from dashboard
+`);
+
+    // Verify manifest has pending keys
+    const status = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(status, null, 'manifest should exist');
+    assert.deepStrictEqual(status!.pending, ['GSD_PAUSE_TEST_KEY_A', 'GSD_PAUSE_TEST_KEY_B']);
+
+    // Simulate what auto-start.ts now does: set pause flags on session
+    const session = new AutoSession();
+    session.active = true;
+    session.currentMilestoneId = 'M001';
+
+    // The new gate logic: if pending keys exist, pause instead of collecting
+    if (status!.pending.length > 0) {
+      session.paused = true;
+      session.pausedForSecrets = true;
+    }
+
+    assert.strictEqual(session.paused, true, 'session should be paused');
+    assert.strictEqual(session.pausedForSecrets, true, 'pausedForSecrets flag should be set');
+
+    // Verify reset() clears pausedForSecrets
+    session.reset();
+    assert.strictEqual(session.pausedForSecrets, false, 'reset() should clear pausedForSecrets');
+  } finally {
+    delete process.env.GSD_PAUSE_TEST_KEY_A;
+    delete process.env.GSD_PAUSE_TEST_KEY_B;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('secrets gate: no pending keys do not set pausedForSecrets', async () => {
+  const tmp = makeTempDir('gate-no-pause');
+  const savedKey = process.env.GSD_NO_PAUSE_TEST_KEY;
+  try {
+    process.env.GSD_NO_PAUSE_TEST_KEY = 'already-set';
+
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### GSD_NO_PAUSE_TEST_KEY
+
+**Service:** ServiceX
+**Status:** pending
+**Destination:** dotenv
+
+1. Already in env
+`);
+
+    const status = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(status, null, 'manifest should exist');
+    assert.deepStrictEqual(status!.pending, [], 'no pending keys — already in env');
+
+    // Simulate gate logic — no pending keys, no pause
+    const session = new AutoSession();
+    session.active = true;
+
+    if (status!.pending.length > 0) {
+      session.paused = true;
+      session.pausedForSecrets = true;
+    }
+
+    assert.strictEqual(session.paused, false, 'session should NOT be paused');
+    assert.strictEqual(session.pausedForSecrets, false, 'pausedForSecrets should NOT be set');
+  } finally {
+    delete process.env.GSD_NO_PAUSE_TEST_KEY;
+    if (savedKey !== undefined) process.env.GSD_NO_PAUSE_TEST_KEY = savedKey;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ─── Scenario 3: No pending keys — all collected or in env ──────────────────
+
 test('secrets gate: no pending keys — getManifestStatus shows pending.length === 0', async () => {
   const tmp = makeTempDir('gate-no-pending');
   const savedKey = process.env.GSD_GATE_TEST_ENVKEY;