@opengsd/gsd-pi 1.2.0-dev.955e4da0 → 1.2.0-dev.a6376d75

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -118,6 +118,51 @@ function makeRepoWithMultipleStrandedMilestones(): string {
   return base;
 }
 
+function makeRepoWithOnlySiblingStrandedAndLockedActive(): string {
+  // Locked milestone (M002) is the active row but has NO stranded
+  // milestone branch. A sibling milestone (M001) has a stranded branch.
+  // A parallel worker locked to M002 must skip the sibling's stranded
+  // action entirely — neither block on it nor adopt it.
+  const base = mkdtempSync(join(tmpdir(), "gsd-locked-no-stranded-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M002"), { recursive: true });
+  // M002 has CONTEXT so bootstrap's pre-planning gate doesn't route to
+  // showSmartEntry and the test reaches the post-lock session-init path.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M002", "M002-CONTEXT.md"),
+    "# M002 context\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"none\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  // Sibling M001 has stranded work on milestone/M001.
+  runGit(base, ["checkout", "-b", "milestone/M001"]);
+  writeFileSync(join(base, "m001.txt"), "sibling stranded work\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M001 in progress"]);
+  runGit(base, ["checkout", "main"]);
+
+  // M002 has no stranded branch at all.
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  // Both milestones are open so the stranded audit produces a blocking
+  // action for the sibling (M001). M002 is the lock target and active
+  // row; getActiveMilestoneId honors the lock regardless of M001 order.
+  insertMilestone({ id: "M001", title: "Sibling milestone", status: "pending" });
+  insertMilestone({ id: "M002", title: "Locked milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
 function makeRepoWithActiveMismatchAndStrandedTarget(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-targeted-stranded-bootstrap-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
@@ -455,6 +500,197 @@ test("bootstrap blocks active stranded recovery when another open milestone also
   }
 });
 
+test("parallel worker recovers its locked stranded milestone despite stranded siblings", async () => {
+  const base = makeRepoWithMultipleStrandedMilestones();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: () => ({ ok: true, mode: "none", path: base }),
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "branch" }]);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.match(messages, /Resuming saved milestone work for M002/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M002/);
+    assert.doesNotMatch(messages, /\/gsd auto M001/);
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("locked worker with no own stranded action does not adopt sibling stranded action", async () => {
+  const base = makeRepoWithOnlySiblingStrandedAndLockedActive();
+  const previousCwd = process.cwd();
+  const previousLock = process.env.GSD_MILESTONE_LOCK;
+  const previousWorker = process.env.GSD_PARALLEL_WORKER;
+  const s = new AutoSession();
+  const adoptCalls: Array<{ milestoneId: string; mode: string }> = [];
+  const enterCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    process.env.GSD_PARALLEL_WORKER = "1";
+    process.env.GSD_MILESTONE_LOCK = "M002";
+
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
+        lockBase: () => base,
+        buildLifecycle: () => ({
+          adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
+            s.basePath = sessionBase;
+            if (originalBase !== undefined) {
+              s.originalBasePath = originalBase;
+            } else if (!s.originalBasePath) {
+              s.originalBasePath = sessionBase;
+            }
+          },
+          enterMilestone: (mid: string) => {
+            enterCalls.push(mid);
+            return { ok: true, mode: "none", path: base };
+          },
+          adoptStrandedMilestone: (
+            milestoneId: string,
+            sessionBase: string,
+            _ctx: unknown,
+            opts: { mode: "worktree" | "branch" },
+          ) => {
+            adoptCalls.push({ milestoneId, mode: opts.mode });
+            s.basePath = sessionBase;
+            s.originalBasePath = sessionBase;
+            s.strandedRecoveryIsolationMode = opts.mode;
+            return { ok: true, mode: opts.mode, path: sessionBase };
+          },
+          adoptOrphanWorktree: <T extends { merged: boolean }>(
+            _mid: string,
+            _base: string,
+            run: () => T,
+          ): T => run(),
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    const messages = notifications.map((entry) => entry.message).join("\n");
+    assert.equal(ready, true);
+    // Must not adopt M001 (the sibling stranded action) — the locked
+    // worker has no stranded action of its own, so adoption should not
+    // run at all. enterMilestone for M002 is also gated off by
+    // isolation=none with no stranded recoveryMode (#742 regression).
+    assert.deepEqual(adoptCalls, []);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.doesNotMatch(messages, /Resuming saved milestone work for M001/);
+    assert.doesNotMatch(messages, /blocks auto-mode before M002/);
+  } finally {
+    if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
+    else process.env.GSD_MILESTONE_LOCK = previousLock;
+    if (previousWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+    else process.env.GSD_PARALLEL_WORKER = previousWorker;
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("bootstrap honors explicit solo milestone lock when recovering stranded target worktree", async () => {
   const base = makeRepoWithActiveMismatchAndStrandedTarget();
   const previousCwd = process.cwd();

package/src/resources/extensions/gsd/tests/auto-unit-closeout.test.ts

@@ -1,13 +1,23 @@
 // Project/App: gsd-pi
 // File Purpose: Regression tests for auto-unit closeout activity classification.
 
-import test from "node:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import test, { type TestContext } from "node:test";
 import assert from "node:assert/strict";
 
 import {
   isSuspiciousGhostCompletion,
   snapshotUnitActivity,
 } from "../auto-unit-closeout.ts";
+import {
+  closeUnit,
+  type UnitCloseoutRequest,
+  type UnitCloseoutDeps,
+} from "../unit-closeout.ts";
+import type { NotifySeverity } from "../notification-store.js";
 
 function makeCtx(entries: unknown[]) {
   return {
@@ -17,6 +27,38 @@ function makeCtx(entries: unknown[]) {
   } as any;
 }
 
+function createTempGitRepo(t: TestContext): string {
+  const dir = mkdtempSync(join(tmpdir(), "closeout-test-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  execSync("git init", { cwd: dir });
+  execSync("git config user.email test@test.com", { cwd: dir });
+  execSync("git config user.name Test", { cwd: dir });
+  return dir;
+}
+
+function makeMockDeps(overrides: Partial<UnitCloseoutDeps> = {}): UnitCloseoutDeps & { notifications: Array<{ message: string; severity: NotifySeverity }> } {
+  const notifications: Array<{ message: string; severity: NotifySeverity }> = [];
+  return {
+    isolationMode: () => "none",
+    currentBranch: () => "main",
+    commit: () => null,
+    notify: (message, severity) => notifications.push({ message, severity }),
+    notifications,
+    ...overrides,
+  };
+}
+
+function baseRequest(overrides: Partial<UnitCloseoutRequest> = {}): UnitCloseoutRequest {
+  return {
+    basePath: "/tmp/ignored",
+    unitType: "complete-milestone",
+    unitId: "M001",
+    boundary: "milestone",
+    outcome: "complete",
+    ...overrides,
+  };
+}
+
 test("isSuspiciousGhostCompletion rejects fast completions with no assistant output or tools", () => {
   const startedAt = Date.now();
   const ctx = makeCtx([]);
@@ -66,3 +108,129 @@ test("snapshotUnitActivity counts assistant messages and tool calls", () => {
     assistantMessages: 1,
   });
 });
+
+test("closeUnit: nothing-to-commit / isolation none", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => null,
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "nothing-to-commit");
+  assert.equal(result.commitMessage, null);
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+
+test("closeUnit: committed / isolation none", (t) => {
+  const dir = createTempGitRepo(t);
+  writeFileSync(join(dir, "file.txt"), "hello");
+  execSync("git add file.txt", { cwd: dir });
+
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => "Add file.txt",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(result.commitMessage, "Add file.txt");
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+
+test("closeUnit: milestone-branch / worktree isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "milestone/M001",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "milestone-branch");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "info");
+  assert.match(deps.notifications[0].message, /Merge it to the integration branch/);
+});
+
+test("closeUnit: isolation-bypassed / worktree isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "main",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "warning");
+  assert.match(deps.notifications[0].message, /completed outside a milestone worktree\/branch/);
+});
+
+test("closeUnit: isolation-bypassed / branch isolation", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "branch",
+    currentBranch: () => "main",
+    commit: () => "Complete M001",
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "isolation-bypassed");
+  assert.equal(result.commitMessage, "Complete M001");
+  assert.ok(result.notice);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "warning");
+  assert.match(deps.notifications[0].message, /completed outside a milestone worktree\/branch/);
+});
+
+test("closeUnit: commit-failed", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "none",
+    commit: () => {
+      throw new Error("simulated commit failure");
+    },
+  });
+
+  const result = closeUnit(baseRequest({ basePath: dir, boundary: "milestone" }), deps);
+
+  assert.equal(result.gitVerdict, "commit-failed");
+  assert.equal(result.commitMessage, null);
+  assert.ok(result.notice);
+  assert.match(result.notice!, /simulated commit failure/);
+  assert.equal(deps.notifications.length, 1);
+  assert.equal(deps.notifications[0].severity, "error");
+});
+
+test("closeUnit: task boundary ignores isolation verdict", (t) => {
+  const dir = createTempGitRepo(t);
+  const deps = makeMockDeps({
+    isolationMode: () => "worktree",
+    currentBranch: () => "main",
+    commit: () => "Complete task",
+  });
+
+  const result = closeUnit(
+    baseRequest({ basePath: dir, boundary: "task", unitType: "execute-task", unitId: "M001/S01/T01" }),
+    deps,
+  );
+
+  assert.equal(result.gitVerdict, "committed");
+  assert.equal(result.commitMessage, "Complete task");
+  assert.equal(result.notice, undefined);
+  assert.equal(deps.notifications.length, 0);
+});
+

package/src/resources/extensions/gsd/tests/blocked-models.test.ts

@@ -8,7 +8,10 @@ import { join } from "node:path";
 
 import {
   blockModel,
+  blockModelUntil,
+  clearTemporaryModelBlocksForTest,
   isModelBlocked,
+  isModelTemporarilyUnavailable,
   loadBlockedModels,
 } from "../blocked-models.ts";
 
@@ -96,3 +99,19 @@ test("blocked-models: file created under .gsd/runtime/", () => {
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("blocked-models: temporary rate-limit blocks expire without persisting", () => {
+  const base = mkBase();
+  try {
+    clearTemporaryModelBlocksForTest();
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() + 60_000, "session limit");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), true);
+    assert.equal(loadBlockedModels(base).length, 0, "rate-limit windows must not persist as account blocks");
+
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() - 1, "expired");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), false);
+  } finally {
+    clearTemporaryModelBlocksForTest();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/browser-automation-contract-fixture.ts

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+
+import {
+	getUatBrowserToolSupportError,
+	hasUatBrowserToolSurface,
+	type UatType,
+} from "../uat-policy.ts";
+
+export const BROWSER_AUTOMATION_CONTRACT_TOOLS = {
+	piProvider: ["read", "browser_navigate"],
+	externalMcpClient: ["read", "mcp__gsd-browser__browser_navigate"],
+	externalMcpWildcard: ["read", "mcp__gsd-browser__*"],
+	otherBrowserMcp: ["read", "mcp__browser-uat__*"],
+	workflowOnly: ["read", "mcp__gsd-workflow__*"],
+	withoutBrowser: ["read", "gsd_uat_exec"],
+} as const;
+
+export function assertBrowserAutomationContractAvailable(tools: readonly string[]): void {
+	assert.equal(hasUatBrowserToolSurface(tools), true, `${tools.join(", ")} should satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserAutomationContractMissing(tools: readonly string[] | undefined): void {
+	assert.equal(hasUatBrowserToolSurface(tools), false, `${tools?.join(", ") ?? "undefined"} should not satisfy the Browser Automation Contract`);
+}
+
+export function assertBrowserBackedUatCanDispatch(options: {
+	uatType: UatType;
+	activeTools: readonly string[] | undefined;
+	registeredTools?: readonly string[];
+}): void {
+	assert.equal(
+		getUatBrowserToolSupportError({
+			...options,
+			milestoneId: "M001",
+			sliceId: "S01",
+		}),
+		null,
+	);
+}

package/src/resources/extensions/gsd/tests/browser-contract.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  BROWSER_CONTRACT_TOOL_NAMES,
+  BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES,
+  hasBrowserContractPrefix,
+  isBrowserContractToolName,
+} from "../../shared/browser-contract.ts";
+import { isUatBrowserToolName } from "../uat-policy.ts";
+import { BROWSER_REQUIREMENT_RE, BROWSER_RUNTIME_RE } from "../browser-evidence.ts";
+
+// Note: RUN_UAT_BROWSER_TOOL_NAMES and MANAGED_GSD_BROWSER_TOOL_NAMES are
+// reference-equal aliases of BROWSER_CONTRACT_TOOL_NAMES, and the managed
+// adapter's spec table is Record-keyed by BrowserContractToolName — both
+// derivations are pinned by the type system, not by runtime assertions here.
+describe("Browser Automation Contract parity", () => {
+  it("every contract name satisfies the UAT browser-tool predicate, bare and MCP-prefixed", () => {
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(isUatBrowserToolName(name), true, name);
+      assert.equal(isUatBrowserToolName(`mcp__gsd-browser__${name}`), true, `mcp__gsd-browser__${name}`);
+    }
+  });
+
+  it("contract names are canonical browser_* names with no duplicates", () => {
+    assert.equal(new Set(BROWSER_CONTRACT_TOOL_NAMES).size, BROWSER_CONTRACT_TOOL_NAMES.length);
+    for (const name of BROWSER_CONTRACT_TOOL_NAMES) {
+      assert.equal(hasBrowserContractPrefix(name), true, name);
+      assert.equal(isBrowserContractToolName(name), true, name);
+    }
+    assert.equal(isBrowserContractToolName("browser_not_a_real_tool"), false);
+    assert.equal(hasBrowserContractPrefix("gsd_uat_exec"), false);
+  });
+
+  it("evidence-signal names stay a subset of the contract and drive the detection regexes", () => {
+    for (const name of BROWSER_EVIDENCE_SIGNAL_TOOL_NAMES) {
+      assert.equal(isBrowserContractToolName(name), true, name);
+      // Identifier-shaped names keep the regex splice in browser-evidence.ts escape-free.
+      assert.match(name, /^browser_[a-z_]+$/);
+      assert.match(`Verified via ${name} call`, BROWSER_REQUIREMENT_RE);
+      assert.match(`Verified via ${name} call`, BROWSER_RUNTIME_RE);
+    }
+  });
+});