gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.eaa4973bc

package/src/resources/extensions/gsd/tests/file-lock.test.ts

@@ -52,7 +52,7 @@ test("withFileLock: executes callback when file does not exist", async () => {
   }
 });
 
-test("withFileLockSync: falls back to unlocked callback on ELOCKED", () => {
+test("withFileLockSync: throws ELOCKED by default (no silent fallback)", () => {
   if (!hasProperLockfile() || process.platform === "win32") {
     return;
   }
@@ -65,19 +65,56 @@ test("withFileLockSync: falls back to unlocked callback on ELOCKED", () => {
   const release = lockfile.lockSync(filePath, { retries: 0, stale: 10000 });
   try {
     let called = 0;
-    const result = withFileLockSync(filePath, () => {
-      called++;
-      return "fallback-ok";
-    });
+    assert.throws(
+      () => {
+        withFileLockSync(
+          filePath,
+          () => {
+            called++;
+            return "should-not-return";
+          },
+          { retries: 0 },
+        );
+      },
+      (err: any) => err?.code === "ELOCKED",
+    );
+    assert.equal(called, 0, "callback must not run when lock cannot be acquired");
+  } finally {
+    release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLockSync: onLocked=\"skip\" runs callback unlocked on ELOCKED", () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = lockfile.lockSync(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = withFileLockSync(
+      filePath,
+      () => {
+        called++;
+        return "fallback-ok";
+      },
+      { retries: 0, onLocked: "skip" },
+    );
     assert.equal(result, "fallback-ok");
-    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+    assert.equal(called, 1, "callback should run when onLocked is skip");
   } finally {
     release();
     rmSync(dir, { recursive: true, force: true });
   }
 });
 
-test("withFileLock: falls back to unlocked callback on ELOCKED", async () => {
+test("withFileLock: throws ELOCKED by default (no silent fallback)", async () => {
   if (!hasProperLockfile() || process.platform === "win32") {
     return;
   }
@@ -90,12 +127,49 @@ test("withFileLock: falls back to unlocked callback on ELOCKED", async () => {
   const release = await lockfile.lock(filePath, { retries: 0, stale: 10000 });
   try {
     let called = 0;
-    const result = await withFileLock(filePath, async () => {
-      called++;
-      return "fallback-ok";
-    });
+    await assert.rejects(
+      async () => {
+        await withFileLock(
+          filePath,
+          async () => {
+            called++;
+            return "should-not-return";
+          },
+          { retries: 0 },
+        );
+      },
+      (err: any) => err?.code === "ELOCKED",
+    );
+    assert.equal(called, 0, "callback must not run when lock cannot be acquired");
+  } finally {
+    await release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLock: onLocked=\"skip\" runs callback unlocked on ELOCKED", async () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = await lockfile.lock(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = await withFileLock(
+      filePath,
+      async () => {
+        called++;
+        return "fallback-ok";
+      },
+      { retries: 0, onLocked: "skip" },
+    );
     assert.equal(result, "fallback-ok");
-    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+    assert.equal(called, 1, "callback should run when onLocked is skip");
   } finally {
     await release();
     rmSync(dir, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/src/resources/extensions/gsd/tests/mcp-client-security.test.ts

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+import {
+  _buildMcpChildEnvForTest,
+  _buildMcpTrustConfirmOptionsForTest,
+} from "../../mcp-client/index.ts";
+
+test("MCP stdio child env only includes safe inherited keys plus explicit config env", () => {
+  const previousSecret = process.env.SECRET_MCP_TEST_TOKEN;
+  const previousPath = process.env.PATH;
+  try {
+    process.env.SECRET_MCP_TEST_TOKEN = "should-not-leak";
+    process.env.PATH = "/usr/bin";
+
+    const env = _buildMcpChildEnvForTest({
+      EXPLICIT_TOKEN: "${SECRET_MCP_TEST_TOKEN}",
+      PLAIN_VALUE: "ok",
+    });
+
+    assert.equal(env.PATH, "/usr/bin");
+    assert.equal(env.SECRET_MCP_TEST_TOKEN, undefined);
+    assert.equal(env.EXPLICIT_TOKEN, "should-not-leak");
+    assert.equal(env.PLAIN_VALUE, "ok");
+  } finally {
+    if (previousSecret === undefined) delete process.env.SECRET_MCP_TEST_TOKEN;
+    else process.env.SECRET_MCP_TEST_TOKEN = previousSecret;
+    if (previousPath === undefined) delete process.env.PATH;
+    else process.env.PATH = previousPath;
+  }
+});
+
+test("MCP stdio trust confirmation is abort-aware", () => {
+  const controller = new AbortController();
+  const options = _buildMcpTrustConfirmOptionsForTest(controller.signal);
+
+  assert.equal(options.timeout, 120_000);
+  assert.equal(options.signal, controller.signal);
+});
+
+test("MCP client uses a single in-flight connection per canonical server", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /const pendingConnections = new Map<string, Promise<Client>>\(\)/);
+  assert.match(source, /const pending = pendingConnections\.get\(config\.name\)/);
+  assert.match(source, /pendingConnections\.set\(config\.name, connectionPromise\)/);
+  assert.match(source, /pendingConnections\.delete\(config\.name\)/);
+  assert.match(source, /env: config\.env \?\? \{\}/);
+});
+
+test("MCP stdio trust is persisted only after a successful connection", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+  const connectIndex = source.indexOf("await client.connect(transport");
+  const trustIndex = source.indexOf("trustedStdioServers.add(approvedTrustKey)");
+
+  assert.ok(connectIndex > -1, "connectServer should await client.connect");
+  assert.ok(trustIndex > connectIndex, "trust should be recorded after client.connect succeeds");
+  assert.doesNotMatch(source, /assertTrustedStdioServer[\s\S]*trustedStdioServers\.add\(trustKey\)/);
+});
+
+test("MCP client closes transports after failed connection attempts", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /catch \(err\) \{[\s\S]*await transport\.close\(\)/);
+  assert.match(source, /catch \(err\) \{[\s\S]*await client\.close\(\)/);
+  assert.match(source, /catch \(err\) \{[\s\S]*throw err/);
+});
+
+test("MCP client clears process-local trust and closes transports on session cleanup", () => {
+  const source = readFileSync(new URL("../../mcp-client/index.ts", import.meta.url), "utf8");
+
+  assert.match(source, /async function closeAll\(\)[\s\S]*await conn\.transport\.close\(\)/);
+  assert.match(source, /async function closeAll\(\)[\s\S]*pendingConnections\.clear\(\)/);
+  assert.match(source, /async function closeAll\(\)[\s\S]*trustedStdioServers\.clear\(\)/);
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -404,6 +404,8 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         stepMode: true,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -428,6 +430,8 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         stepMode: false,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -458,6 +462,8 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         stepMode: false,
         basePath: "",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -474,6 +480,39 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
+test("resumeAutoAfterProviderDelay resets provider retry state before restarting auto-mode", async () => {
+  const calls: string[] = [];
+
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: false,
+        basePath: "/tmp/project",
+      }),
+      resetTransientRetryState: () => {
+        calls.push("reset-transient");
+      },
+      resetSessionTimeoutState: () => {
+        calls.push("reset-session-timeout");
+      },
+      startAuto: async () => {
+        calls.push("start-auto");
+      },
+    },
+  );
+
+  assert.equal(result, "resumed");
+  assert.deepEqual(calls, [
+    "reset-transient",
+    "reset-session-timeout",
+    "start-auto",
+  ]);
+});
+
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
 test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
@@ -567,31 +606,6 @@ test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
   );
 });
 
-test("provider-error-resume.ts calls resetTransientRetryState before startAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "provider-error-resume.ts"), "utf-8");
-  assert.ok(
-    src.includes("resetTransientRetryState"),
-    "provider-error-resume.ts must import and call resetTransientRetryState",
-  );
-  // Ensure reset is called BEFORE startAuto — order matters
-  const resetIdx = src.indexOf("resetTransientRetryState()");
-  const startIdx = src.indexOf("await deps.startAuto(");
-  assert.ok(
-    resetIdx !== -1 && startIdx !== -1 && resetIdx < startIdx,
-    "resetTransientRetryState() must be called before deps.startAuto()",
-  );
-  // Session timeout counter must also be reset before startAuto
-  assert.ok(
-    src.includes("resetSessionTimeoutState"),
-    "provider-error-resume.ts must import and call resetSessionTimeoutState",
-  );
-  const sessionResetIdx = src.indexOf("resetSessionTimeoutState()");
-  assert.ok(
-    sessionResetIdx !== -1 && startIdx !== -1 && sessionResetIdx < startIdx,
-    "resetSessionTimeoutState() must be called before deps.startAuto()",
-  );
-});
-
 // ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
 
 test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {

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

@@ -0,0 +1,181 @@
+/**
+ * Tests that /gsd queue is blocked when auto-mode is active.
+ *
+ * Relates to #4704: /gsd queue writes .gsd/PROJECT.md + QUEUE-ORDER.json
+ * directly into the project-root worktree, racing with auto-mode's
+ * pre-merge dirty-tree check and causing __dirty_working_tree__ failures.
+ *
+ * The fix adds an isAutoActive() guard in handleWorkflowCommand before
+ * delegating to showQueue, mirroring the existing /gsd quick guard (#2417).
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify the guard exists in source ──────────────────────
+
+describe("/gsd queue auto-mode guard (#4704)", () => {
+  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // Find the queue command block
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
+
+    const queueBlock = queueBlockMatch[1];
+
+    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
+    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
+    // helper (Tier 2 / #4712).
+    const guardIndex = Math.max(
+      queueBlock.indexOf("isAutoActive()"),
+      queueBlock.indexOf("requireNotAutoActive("),
+    );
+    const showQueueIndex = queueBlock.indexOf("showQueue(");
+
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
+    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
+    assert.ok(
+      guardIndex < showQueueIndex,
+      "auto-mode guard appears before showQueue() call",
+    );
+  });
+
+  it("guard shows error message mentioning /gsd stop", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
+    );
+    assert.ok(
+      src.includes("/gsd stop"),
+      "error message mentions /gsd stop as the resolution",
+    );
+  });
+
+  it("guard returns true (handled) to prevent falling through", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch);
+    const queueBlock = queueBlockMatch[1];
+
+    // The guard block should have its own return true before showQueue
+    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
+    assert.ok(
+      guardBlock.includes("return true"),
+      "guard block returns true before showQueue is reached",
+    );
+  });
+});
+
+// ─── .gsd/audit/ runtime classification regression ──────────────────────────
+
+describe(".gsd/audit/ runtime classification (#4704)", () => {
+  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "gitignore.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
+    );
+  });
+
+  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "git-service.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
+    );
+  });
+
+  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "worktree-manager.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in SKIP_PATHS",
+    );
+  });
+});
+
+// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
+
+describe("Windows pre-merge DB release (#4704)", () => {
+  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    // Locate the stash push line and ensure a win32-gated closeDatabase()
+    // call precedes it in the same function scope.
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
+
+    const beforeStash = src.slice(0, stashIndex);
+    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
+    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
+
+    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
+    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
+    assert.ok(
+      win32Index < closeIndex && closeIndex < stashIndex,
+      "platform guard wraps the closeDatabase() call before the stash",
+    );
+  });
+
+  it("openDatabase is called after the stash to reopen the connection", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    const afterStash = src.slice(stashIndex);
+    assert.ok(
+      afterStash.includes("openDatabase("),
+      "openDatabase() called after the pre-merge stash",
+    );
+  });
+});

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

@@ -35,15 +35,20 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
 
     const quickBlock = quickBlockMatch[1];
 
-    // Verify isAutoActive guard comes BEFORE handleQuick call
-    const guardIndex = quickBlock.indexOf("isAutoActive()");
+    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
+    // Accepts either the inline isAutoActive() check (legacy) or the shared
+    // requireNotAutoActive() helper (#4712).
+    const guardIndex = Math.max(
+      quickBlock.indexOf("isAutoActive()"),
+      quickBlock.indexOf("requireNotAutoActive("),
+    );
     const handleQuickIndex = quickBlock.indexOf("handleQuick(");
 
-    assert.ok(guardIndex !== -1, "isAutoActive() guard exists in quick command block");
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
     assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
     assert.ok(
       guardIndex < handleQuickIndex,
-      "isAutoActive() guard appears before handleQuick() call",
+      "auto-mode guard appears before handleQuick() call",
     );
   });
 
@@ -59,10 +64,11 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
       "utf-8",
     );
 
-    // The error message should tell the user to stop auto-mode first
+    // The shared helper assembles the message dynamically from the command name,
+    // so assert on the message fragment and the /gsd stop instruction.
     assert.ok(
-      src.includes("/gsd quick cannot run while auto-mode is active"),
-      "error message explains that quick cannot run during auto-mode",
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
     );
     assert.ok(
       src.includes("/gsd stop"),