gsd-pi 2.78.1-dev.0fdacd524 → 2.78.1-dev.2d3fd6e71

package/src/resources/extensions/gsd/tests/auto-session-scope.test.ts

@@ -0,0 +1,331 @@
+// GSD-2 + Tests for MilestoneScope threading through AutoSession state (C2)
+//
+// Strategy: construct AutoSession directly + call createWorkspace/scopeMilestone
+// to mirror the rebuildScope() helper in auto.ts — avoids importing the full
+// auto.ts module (too many .js resolved imports).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import type { MilestoneScope } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-scope-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+function makeWorktreeDir(projectDir: string, milestoneId: string): string {
+  const wt = join(projectDir, ".gsd", "worktrees", milestoneId);
+  mkdirSync(wt, { recursive: true });
+  return wt;
+}
+
+/**
+ * Mirror the rebuildScope() helper from auto.ts — computes s.scope from the
+ * same inputs so tests can verify the behaviour without importing auto.ts.
+ */
+function applyRebuildScope(
+  s: AutoSession,
+  rawPath: string,
+  milestoneId: string | null,
+): void {
+  if (!milestoneId) {
+    s.scope = null;
+    return;
+  }
+  try {
+    const workspace = createWorkspace(rawPath);
+    s.scope = scopeMilestone(workspace, milestoneId);
+  } catch {
+    s.scope = null;
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("AutoSession.scope — project mode (basePath equals originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope is null when milestoneId is null", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = null;
+
+    applyRebuildScope(s, projectDir, null);
+
+    assert.equal(s.scope, null);
+  });
+
+  test("scope mode is 'project' when basePath equals originalBasePath", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("scope projectRoot matches realpath of projectDir", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope worktreeRoot is null in project mode", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("scope path methods resolve under the .gsd directory", () => {
+    const mid = "M002";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    const gsd = join(projectDir, ".gsd");
+    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
+  });
+});
+
+describe("AutoSession.scope — worktree mode (basePath differs from originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M001");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope mode is 'worktree' when basePath is the worktree path", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "worktree");
+  });
+
+  test("scope worktreeRoot matches realpath of worktreeDir", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope projectRoot resolves to project root (not worktree)", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope milestoneId matches the milestone being tracked", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+});
+
+describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope reflects the new milestoneId after rebuild", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+
+    assert.ok(s.scope, "initial scope should be set");
+    assert.equal(s.scope.milestoneId, "M001");
+
+    // Simulate milestone transition mid-session
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+
+    assert.ok(s.scope, "scope should be set after transition");
+    assert.equal(s.scope.milestoneId, "M002");
+  });
+
+  test("scope contextFile changes when milestoneId changes", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+    const ctxM001 = s.scope?.contextFile();
+
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+    const ctxM002 = s.scope?.contextFile();
+
+    assert.ok(ctxM001, "M001 contextFile should be set");
+    assert.ok(ctxM002, "M002 contextFile should be set");
+    assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
+    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
+    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+  });
+});
+
+describe("AutoSession.scope — resume from persisted state", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M003");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("resume without worktree: scope mode is project, projectRoot is base", () => {
+    // Mirror the paused-session resume path:
+    //   s.currentMilestoneId = meta.milestoneId
+    //   s.originalBasePath   = meta.originalBasePath || base
+    //   rawPath              = originalBasePath (no worktreePath present)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, s.originalBasePath, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("resume with valid worktree path: scope mode is worktree", () => {
+    // Mirror the paused-session resume path where worktreePath exists on disk:
+    //   rawPath = worktreePath (existsSync true)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = worktreeDir;
+
+    assert.ok(existsSync(worktreeDir), "worktreeDir must exist for this test");
+
+    applyRebuildScope(s, worktreeDir, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "worktree");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope is consistent with direct createWorkspace + scopeMilestone for same inputs", () => {
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set");
+
+    // Build expected scope via lower-level API to verify equivalence
+    const ws = createWorkspace(projectDir);
+    const expected = scopeMilestone(ws, mid);
+
+    assert.equal(s.scope.milestoneId, expected.milestoneId);
+    assert.equal(s.scope.contextFile(), expected.contextFile());
+    assert.equal(s.scope.roadmapFile(), expected.roadmapFile());
+    assert.equal(s.scope.stateFile(), expected.stateFile());
+    assert.equal(s.scope.dbPath(), expected.dbPath());
+    assert.equal(s.scope.milestoneDir(), expected.milestoneDir());
+    assert.equal(s.scope.metaJson(), expected.metaJson());
+  });
+
+  test("reset() clears scope", () => {
+    const mid = "M003";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set before reset");
+
+    s.reset();
+    assert.equal(s.scope, null, "scope must be null after reset()");
+  });
+});

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -7,9 +7,12 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
 import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -61,4 +64,32 @@ describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
       "legacy FS-fallback branch should still use SUMMARY file presence",
     );
   });
+
+  test("cleanStaleRuntimeUnits removes legacy pseudo deep-setup runtime files", () => {
+    const base = join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+    const gsdRoot = join(base, ".gsd");
+    const unitsDir = join(gsdRoot, "runtime", "units");
+    try {
+      mkdirSync(unitsDir, { recursive: true });
+      const staleFiles = [
+        "discuss-milestone-PROJECT.json",
+        "workflow-preferences-WORKFLOW-PREFS.json",
+        "discuss-project-PROJECT.json",
+        "discuss-requirements-REQUIREMENTS.json",
+        "research-decision-RESEARCH-DECISION.json",
+        "research-project-RESEARCH-PROJECT.json",
+      ];
+      const valid = join(unitsDir, "discuss-milestone-M001.json");
+      for (const file of staleFiles) writeFileSync(join(unitsDir, file), "{}\n", "utf-8");
+      writeFileSync(valid, "{}\n", "utf-8");
+
+      const cleaned = cleanStaleRuntimeUnits(gsdRoot, () => false);
+
+      assert.equal(cleaned, staleFiles.length);
+      for (const file of staleFiles) assert.equal(existsSync(join(unitsDir, file)), false);
+      assert.equal(existsSync(valid), true);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/auto-start-index-lock.test.ts

@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
+const source = readFileSync(sourcePath, "utf-8");
+
+test("bootstrapAutoSession blocks on .git/index.lock before git mutations", () => {
+  const preflightIdx = source.indexOf('join(base, ".git", "index.lock")');
+  const initIdx = source.indexOf("nativeInit(base, mainBranch)");
+  const addIdx = source.indexOf("nativeAddAll(base)");
+  const commitIdx = source.indexOf('nativeCommit(base, "chore: init gsd")');
+
+  assert.ok(preflightIdx > -1, "bootstrap must check for .git/index.lock");
+  assert.ok(initIdx > -1, "bootstrap still initializes git when safe");
+  assert.ok(addIdx > -1, "bootstrap still stages bootstrap files when safe");
+  assert.ok(commitIdx > -1, "bootstrap still commits bootstrap files when safe");
+
+  assert.ok(preflightIdx < initIdx, "index.lock preflight must run before git init");
+  assert.ok(preflightIdx < addIdx, "index.lock preflight must run before git add");
+  assert.ok(preflightIdx < commitIdx, "index.lock preflight must run before git commit");
+});
+
+test("bootstrapAutoSession never deletes .git/index.lock", () => {
+  assert.ok(
+    !source.includes("unlinkSync(gitLockFile)") && !source.includes("rmSync(gitLockFile"),
+    "bootstrap must not remove .git/index.lock because git lock staleness is not safe to infer",
+  );
+  assert.ok(
+    !source.includes("STALE_GIT_LOCK_THRESHOLD_MS"),
+    "bootstrap must not use lock age as a deletion heuristic",
+  );
+  assert.ok(
+    source.includes("return releaseLockAndReturn();"),
+    "bootstrap must abort and release the session lock when the git index is locked",
+  );
+});

package/src/resources/extensions/gsd/tests/auto-worktree-registry.test.ts

@@ -0,0 +1,176 @@
+// GSD-2 + Unit tests for the workspace registry that replaced the originalBase singleton
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  getAutoWorktreeOriginalBase,
+  getActiveAutoWorktreeContext,
+  _resetAutoWorktreeOriginalBaseForTests,
+  createAutoWorktree,
+  enterAutoWorktree,
+  teardownAutoWorktree,
+} from "../auto-worktree.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+// Safe: all inputs below are hardcoded test strings, not user input.
+function git(subArgs: string[], cwd: string): void {
+  execFileSync("git", subArgs, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function createTempRepo(t: { after: (fn: () => void) => void }): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "awreg-test-")));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("auto-worktree workspace registry", () => {
+  const savedCwd = process.cwd();
+
+  beforeEach(() => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(savedCwd);
+  });
+
+  test("getAutoWorktreeOriginalBase() is null at baseline", () => {
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+  });
+
+  test("getActiveAutoWorktreeContext() is null at baseline", () => {
+    assert.strictEqual(getActiveAutoWorktreeContext(), null);
+  });
+
+  test("_resetAutoWorktreeOriginalBaseForTests() clears the registry — idempotent", () => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+    _resetAutoWorktreeOriginalBaseForTests();
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+  });
+
+  test("behavioral equivalence: createAutoWorktree populates registry; teardown clears it", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M001");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M001 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    // Before entering: registry must be empty
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "originalBase is null before entering worktree");
+
+    createAutoWorktree(tempDir, "M001");
+
+    // After enter: getAutoWorktreeOriginalBase must equal tempDir
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      tempDir,
+      "getAutoWorktreeOriginalBase() returns projectRoot after createAutoWorktree",
+    );
+
+    // getActiveAutoWorktreeContext must return the correct shape
+    const ctx = getActiveAutoWorktreeContext();
+    assert.ok(ctx !== null, "context is non-null inside worktree");
+    assert.strictEqual(ctx.originalBase, tempDir, "context.originalBase matches tempDir");
+    assert.strictEqual(ctx.worktreeName, "M001", "context.worktreeName is M001");
+    assert.strictEqual(ctx.branch, "milestone/M001", "context.branch is milestone/M001");
+
+    // Teardown: registry must be cleared
+    teardownAutoWorktree(tempDir, "M001");
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "getAutoWorktreeOriginalBase() is null after teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null,
+      "getActiveAutoWorktreeContext() is null after teardown");
+
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("behavioral equivalence: enterAutoWorktree also populates registry", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M002");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M002 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M002");
+
+    // Simulate leaving the worktree (crash/pause)
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(tempDir);
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "registry is empty after manual reset");
+
+    // Re-enter via enterAutoWorktree
+    enterAutoWorktree(tempDir, "M002");
+
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      tempDir,
+      "getAutoWorktreeOriginalBase() returns projectRoot after enterAutoWorktree",
+    );
+    const ctx = getActiveAutoWorktreeContext();
+    assert.ok(ctx !== null, "context is non-null after re-entry");
+    assert.strictEqual(ctx.originalBase, tempDir);
+    assert.strictEqual(ctx.worktreeName, "M002");
+    assert.strictEqual(ctx.branch, "milestone/M002");
+
+    teardownAutoWorktree(tempDir, "M002");
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("single-occupancy: entering a new workspace replaces the previous one", (t) => {
+    const dir1 = createTempRepo(t);
+    const dir2 = createTempRepo(t);
+
+    // Set up milestone in dir1
+    const ms1Dir = join(dir1, ".gsd", "milestones", "M010");
+    mkdirSync(ms1Dir, { recursive: true });
+    writeFileSync(join(ms1Dir, "CONTEXT.md"), "# M010\n");
+    git(["add", "."], dir1);
+    git(["commit", "-m", "add milestone"], dir1);
+
+    // Set up milestone in dir2
+    const ms2Dir = join(dir2, ".gsd", "milestones", "M020");
+    mkdirSync(ms2Dir, { recursive: true });
+    writeFileSync(join(ms2Dir, "CONTEXT.md"), "# M020\n");
+    git(["add", "."], dir2);
+    git(["commit", "-m", "add milestone"], dir2);
+
+    // Enter dir1/M010
+    createAutoWorktree(dir1, "M010");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), dir1,
+      "registry holds dir1 after entering M010");
+
+    // Tear down dir1 cleanly
+    teardownAutoWorktree(dir1, "M010");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry cleared after M010 teardown");
+
+    // Enter dir2/M020 — registry should now hold dir2 only
+    createAutoWorktree(dir2, "M020");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), dir2,
+      "registry holds dir2 after entering M020 (single-occupancy preserved)");
+    assert.notStrictEqual(getAutoWorktreeOriginalBase(), dir1,
+      "dir1 is no longer in the registry");
+
+    teardownAutoWorktree(dir2, "M020");
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+});

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -136,6 +136,30 @@ describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", (
     );
   });
 
+  test("pauseAuto rebuilds STATE.md before releasing the session lock", () => {
+    // pauseAuto must persist the DB-backed state projection so resume/debugging
+    // does not see a stale STATE.md after a mid-unit interruption.
+    const start = autoSrc.indexOf("export async function pauseAuto(");
+    const end = autoSrc.indexOf("/**\n * Build a WorktreeResolverDeps", start);
+    const pauseAutoSection = autoSrc.slice(start, end);
+    assert.ok(pauseAutoSection.length > 0, "Could not locate pauseAuto function");
+
+    const rebuildIndex = pauseAutoSection.indexOf("await rebuildState(s.basePath)");
+    const releaseIndex = pauseAutoSection.indexOf("releaseSessionLock(lockBase())");
+    assert.ok(
+      rebuildIndex >= 0,
+      "pauseAuto must rebuild STATE.md from DB-backed state before pause completes",
+    );
+    assert.ok(
+      releaseIndex >= 0,
+      "pauseAuto must still release the session lock",
+    );
+    assert.ok(
+      rebuildIndex < releaseIndex,
+      "pauseAuto must rebuild state before releasing the session lock",
+    );
+  });
+
   test("run-unit.ts still has its existing clearQueue() call (baseline)", () => {
     // Verify the original clearQueue pattern in run-unit.ts hasn't been removed.
     assert.ok(
@@ -167,3 +191,35 @@ describe("#4365: tool_execution_start hook must pass toolName to markToolStart",
     );
   });
 });
+
+describe("deep setup approval questions pause immediately", () => {
+  test("register-hooks sets pending gate during message_update without aborting the stream", () => {
+    const startMarker = 'pi.on("message_update"';
+    const endMarker = 'pi.on("session_shutdown"';
+    const messageUpdateSection = registerHooksSrc.slice(
+      registerHooksSrc.indexOf(startMarker),
+      registerHooksSrc.indexOf(endMarker),
+    );
+
+    assert.ok(
+      messageUpdateSection.length > 0,
+      "Could not locate message_update approval pause handler",
+    );
+    assert.ok(
+      messageUpdateSection.includes("shouldPauseForUserApprovalQuestion"),
+      "message_update must detect approval/question boundaries",
+    );
+    assert.ok(
+      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("setPendingGate"),
+      "plain-text approval questions must set the durable write gate",
+    );
+    assert.ok(
+      messageUpdateSection.includes("getDiscussionMilestoneIdFor") && messageUpdateSection.includes('"discuss-milestone"'),
+      "foreground milestone discussion questions must also set the durable write gate",
+    );
+    assert.ok(
+      !messageUpdateSection.includes("ctx.abort()"),
+      "message_update must NOT abort the stream — aborting eats the model's question text on external CLI providers; the pending gate set above blocks subsequent tool calls instead",
+    );
+  });
+});