gsd-pi 2.78.1-dev.b6a389b66 → 2.78.1-dev.d8826a445

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -22,6 +22,7 @@ import {
   resetEmptyTurnCounter,
 } from "../guided-flow.ts";
 import { drainLogs } from "../workflow-logger.ts";
+import { resolveMilestoneFile, clearPathCache } from "../paths.ts";
 
 // ─── Test harness ──────────────────────────────────────────────────────────
 
@@ -178,6 +179,79 @@ describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
     }
   });
 
+  test("stale path cache from a prior listing → fresh writes are detected (regression)", () => {
+    // Repro the live binary failure where:
+    //   1. paths.ts cached dir listings were populated when M001/ was empty
+    //      (or the milestone dir didn't yet exist).
+    //   2. The LLM then wrote M001-CONTEXT.md and M001-ROADMAP.md via the
+    //      standard Write tool — which has no awareness of paths.ts caches.
+    //   3. maybeHandleReadyPhraseWithoutFiles called resolveMilestoneFile,
+    //      which read the stale cache and reported the artifacts missing,
+    //      firing a false rejection nudge until MAX_READY_REJECTS aborted
+    //      the auto-start with `LLM signaled "ready" 3 times without
+    //      writing files`.
+    //
+    // The fix busts the path cache at the top of the validator before
+    // re-resolving. This test fails pre-fix (handled === true) because the
+    // cache returns the empty listing it captured in step (a).
+    const base = mkBase();
+    try {
+      const mDir = join(base, ".gsd", "milestones", "M001");
+
+      // (a) Prime the cache with a listing that DOES NOT include M001's
+      //     CONTEXT/ROADMAP files. mkBase() has already created the M001
+      //     directory but nothing inside it yet — so this readdir caches an
+      //     empty entry list keyed by the M001 dir path.
+      clearPathCache();
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "precondition: resolver must report missing before files are written",
+      );
+
+      // (b) Write the artifacts directly to disk (simulates the LLM Write
+      //     tool — no clearPathCache() call between the write and the
+      //     validator).
+      writeFileSync(join(mDir, "M001-CONTEXT.md"), "# ctx");
+      writeFileSync(join(mDir, "M001-ROADMAP.md"), "# roadmap");
+
+      // (c) Sanity: the cache is still stale. Without the fix, the
+      //     validator would still see the empty cached listing.
+      assert.equal(
+        resolveMilestoneFile(base, "M001", "CONTEXT"),
+        null,
+        "stale cache still reports missing pre-clearPathCache",
+      );
+
+      // (d) Run the validator. With the fix it busts the cache before
+      //     resolving and returns false (no nudge). Without the fix it
+      //     fires the nudge.
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(
+        handled,
+        false,
+        "fresh writes must not trigger the rejection nudge — cache must be busted before resolution",
+      );
+      assert.equal(cap.messages.length, 0, "no nudge sent");
+      assert.equal(
+        cap.notifies.length,
+        0,
+        "no rejection notify when files exist on disk",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
   test("legacy unprefixed files present → no nudge", () => {
     const base = mkBase();
     try {

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -25,12 +25,15 @@ test("register-hooks unlocks milestone depth verification from question id witho
   const dir = makeTempDir("manual");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -101,12 +104,15 @@ test("register-hooks clears depth gate when remote (Telegram/Slack/Discord) answ
   const dir = makeTempDir("remote");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
@@ -167,12 +173,15 @@ test("register-hooks returns hard blocker when depth question is cancelled", asy
   const dir = makeTempDir("cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
@@ -228,12 +237,15 @@ test("register-hooks gates MCP ask_user_questions cancellation before requiremen
   const dir = makeTempDir("mcp-cancelled");
   const originalCwd = process.cwd();
   process.chdir(dir);
-  resetWriteGateState();
+  resetWriteGateState(dir);
 
   t.after(() => {
-    resetWriteGateState();
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();

package/src/resources/extensions/gsd/tests/resume-missing-worktree-warning.test.ts

@@ -0,0 +1,209 @@
+// GSD-2 + Regression tests for missing-worktree warning on resume (M4 fix)
+//
+// When paused-session.json records a worktreePath that no longer exists on disk,
+// the resume path must emit a logWarning("session", ...) describing the situation
+// rather than silently falling back to project-root mode.
+//
+// Strategy: drive the exported _warnIfWorktreeMissingForTest seam directly
+// (mirrors the exact conditional used at the two resume sites in auto.ts),
+// and independently verify the scope fallback via createWorkspace/scopeMilestone
+// as in auto-session-scope.test.ts.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  logWarning,
+  peekLogs,
+  _resetLogs,
+  setStderrLoggingEnabled,
+} from "../workflow-logger.ts";
+import { _warnIfWorktreeMissingForTest } from "../auto.ts";
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-resume-warn-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// Mirror the rebuildScope() fallback from auto.ts when worktree is missing.
+function applyProjectRootScope(
+  s: AutoSession,
+  projectDir: string,
+  milestoneId: string,
+): void {
+  const workspace = createWorkspace(projectDir);
+  s.scope = scopeMilestone(workspace, milestoneId);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("resume: missing worktree warning emission", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("logWarning is called when worktreePath is set but directory is missing", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M001-nonexistent");
+    // missingPath was never created — existsSync returns false
+
+    const warned = _warnIfWorktreeMissingForTest(missingPath, "M001");
+
+    assert.equal(warned, true, "_warnIfWorktreeMissingForTest should return true when path is missing");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1, "exactly one warning should be emitted");
+    assert.equal(logs[0].severity, "warn");
+    assert.equal(logs[0].component, "session");
+    assert.ok(
+      logs[0].message.includes(missingPath),
+      `warning message should include the missing path; got: ${logs[0].message}`,
+    );
+    assert.ok(
+      logs[0].message.includes("missing"),
+      "warning message should mention 'missing'",
+    );
+  });
+
+  test("logWarning message includes milestone ID", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M042-gone");
+    _warnIfWorktreeMissingForTest(missingPath, "M042");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0].context?.milestoneId, "M042");
+  });
+
+  test("logWarning is NOT called when worktreePath is null", () => {
+    const warned = _warnIfWorktreeMissingForTest(null, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is null");
+  });
+
+  test("logWarning is NOT called when worktreePath is undefined", () => {
+    const warned = _warnIfWorktreeMissingForTest(undefined, "M001");
+
+    assert.equal(warned, false);
+    assert.equal(peekLogs().length, 0, "no warning when worktreePath is undefined");
+  });
+
+  test("logWarning is NOT called when worktreePath exists on disk", () => {
+    const existingWorktree = join(projectDir, ".gsd", "worktrees", "M001");
+    mkdirSync(existingWorktree, { recursive: true });
+
+    const warned = _warnIfWorktreeMissingForTest(existingWorktree, "M001");
+
+    assert.equal(warned, false, "no warning when path exists");
+    assert.equal(peekLogs().length, 0);
+  });
+
+  test("warning message mentions project-root fallback action", () => {
+    const missingPath = join(projectDir, ".gsd", "worktrees", "M099-deleted");
+    _warnIfWorktreeMissingForTest(missingPath, "M099");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.ok(
+      logs[0].message.includes("project-root mode"),
+      "warning should mention project-root mode fallback",
+    );
+    assert.ok(
+      logs[0].message.includes("gsd-debug"),
+      "warning should suggest /gsd-debug recovery action",
+    );
+  });
+});
+
+describe("resume: scope fallback to project-root mode when worktree is missing", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+    _resetLogs();
+    setStderrLoggingEnabled(false);
+  });
+
+  afterEach(() => {
+    setStderrLoggingEnabled(true);
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope.workspace.mode is 'project' after fallback from missing worktree", () => {
+    const mid = "M001";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    // Simulate auto.ts resume path: worktreePath is set but missing → use projectDir
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Fallback: use originalBasePath (project root)
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set after fallback");
+    assert.equal(s.scope.workspace.mode, "project");
+  });
+
+  test("scope.milestoneId is preserved after project-root fallback", () => {
+    const mid = "M002";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    applyProjectRootScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("does not throw when worktree path is missing and scope fallback is applied", () => {
+    const mid = "M003";
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    assert.doesNotThrow(() => {
+      _warnIfWorktreeMissingForTest(missingPath, mid);
+      applyProjectRootScope(s, projectDir, mid);
+    }, "resume with missing worktree must not throw");
+  });
+
+  test("warning is emitted once per missing worktree — no double-emission", () => {
+    const mid = "M004";
+    const missingPath = join(projectDir, ".gsd", "worktrees", mid);
+
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    // Simulating the second call as would happen if the resume-re-entry site
+    // also fires (e.g. pausedSession and freshStartAssessment both carry the path)
+    _warnIfWorktreeMissingForTest(missingPath, mid);
+
+    const logs = peekLogs();
+    // Two calls → two warnings (one per site — consistent with the two sites in auto.ts)
+    assert.equal(logs.length, 2, "each call to the seam emits one warning");
+    assert.equal(logs[0].component, "session");
+    assert.equal(logs[1].component, "session");
+  });
+});