@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.6ccd27b3

package/src/resources/extensions/gsd/tests/browser-daemon-auto-prep.test.ts

@@ -0,0 +1,144 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  prepareBrowserDaemonForUat,
+  shouldWarmBrowserDaemonForUat,
+} from "../browser-daemon-auto-prep.ts";
+import { commitBrowserEngineResolution } from "../../browser-tools/engine/selection.ts";
+import { resolveGsdBrowserCliAvailability } from "../../shared/gsd-browser-cli.ts";
+
+const GSD_BROWSER_ENGINE = { GSD_BROWSER_ENGINE: "gsd-browser" } as const;
+
+test("shouldWarmBrowserDaemonForUat skips artifact-driven UAT", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables Claude Code browser UAT when gsd-browser is available", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/project",
+      env: GSD_BROWSER_ENGINE,
+    }),
+    true,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat enables warm-up for Claude Code oauth/apiKey when engine is gsd-browser", (t) => {
+  const availability = resolveGsdBrowserCliAvailability();
+  if (!availability.available) {
+    t.skip("bundled gsd-browser CLI unavailable");
+  }
+
+  for (const sessionAuthMode of ["oauth", "apiKey"] as const) {
+    assert.equal(
+      shouldWarmBrowserDaemonForUat({
+        uatType: "browser-executable",
+        sessionProvider: "claude-code",
+        sessionAuthMode,
+        sessionBaseUrl: "https://api.anthropic.com",
+        projectRoot: "/tmp/project",
+        env: GSD_BROWSER_ENGINE,
+      }),
+      true,
+      `expected warm-up for sessionAuthMode=${sessionAuthMode}`,
+    );
+  }
+});
+
+test("shouldWarmBrowserDaemonForUat skips legacy Playwright engine for Claude Code", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "oauth",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_ENGINE: "legacy" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat uses session-committed ambient engine for non-Claude providers", () => {
+  const projectRoot = "/tmp/ambient-engine-project";
+  commitBrowserEngineResolution(projectRoot, {
+    engine: "legacy",
+    source: "probe",
+    reason: "gsd-browser daemon connect failed (test); using legacy Playwright",
+  });
+
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "openai",
+      projectRoot,
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when browser MCP is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_MCP_ENABLED: "0" },
+    }),
+    false,
+  );
+});
+
+test("shouldWarmBrowserDaemonForUat skips when warm-up is disabled", () => {
+  assert.equal(
+    shouldWarmBrowserDaemonForUat({
+      uatType: "browser-executable",
+      sessionProvider: "claude-code",
+      projectRoot: "/tmp/project",
+      env: { GSD_BROWSER_WARMUP: "0" },
+    }),
+    false,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns null when warm-up is not required", () => {
+  assert.equal(
+    prepareBrowserDaemonForUat({
+      uatType: "artifact-driven",
+      sessionProvider: "claude-code",
+      sessionAuthMode: "externalCli",
+      projectRoot: "/tmp/example-project",
+    }),
+    null,
+  );
+});
+
+test("prepareBrowserDaemonForUat returns actionable error when daemon start fails", () => {
+  const error = prepareBrowserDaemonForUat({
+    uatType: "browser-executable",
+    sessionProvider: "claude-code",
+    sessionAuthMode: "externalCli",
+    projectRoot: "/tmp/example-project",
+    env: {
+      ...GSD_BROWSER_ENGINE,
+      GSD_BROWSER_MCP_COMMAND: "/definitely/missing/gsd-browser",
+    },
+  });
+
+  assert.match(error ?? "", /gsd-browser daemon failed to start/i);
+});

package/src/resources/extensions/gsd/tests/checkout-branch-stash-guard.test.ts

@@ -5,7 +5,7 @@ import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSy
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkoutBranchWithStashGuard } from "../auto-worktree.ts";
+import { checkoutBranchWithStashGuard } from "../worktree-git-recovery.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, {
@@ -159,4 +159,69 @@ describe("checkoutBranchWithStashGuard", () => {
     const stashList = git(["stash", "list"], repo).trim();
     assert.equal(stashList, "");
   });
+
+  test("auto-resolves combined non-.gsd untracked collision and .gsd index conflict", (t) => {
+    // Regression for: gate checked nonGsdUnmerged.length === 0 but ignored
+    // .gsd/ index conflicts, so a failed pop with both an untracked non-.gsd/
+    // collision AND a .gsd/ tracked conflict would drop the stash while leaving
+    // .gsd/ index unmerged entries unresolved.
+    const repo = createRepo(t);
+    // Add .gsd/DECISIONS.md to base so both branches diverge from it
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "base\n");
+    git(["add", ".gsd/DECISIONS.md"], repo);
+    git(["commit", "-m", "add decisions"], repo);
+
+    git(["checkout", "-b", "milestone/M003"], repo);
+    // Branch has its own version of DECISIONS.md (non-JSONL .gsd/ file)
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "target-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".gsd/DECISIONS.md", ".harness/settings.json"], repo);
+    git(["commit", "-m", "branch state"], repo);
+    git(["checkout", "main"], repo);
+
+    // On main: tracked .gsd/ change (creates unmerged index entry on pop) +
+    // untracked harness file (triggers "already exists, no checkout").
+    writeFileSync(join(repo, ".gsd", "DECISIONS.md"), "local-version\n");
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M003", "test-combined-gsd-conflict");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M003");
+    const decisions = readFileSync(join(repo, ".gsd", "DECISIONS.md"), "utf8");
+    assert.equal(decisions, "target-version\n");
+    assert.doesNotMatch(decisions, /<<<<<<<|=======|>>>>>>>/);
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
+
+  test("auto-resolves non-.gsd untracked restore collisions (e.g. harness config outside .gsd/)", (t) => {
+    const repo = createRepo(t);
+    // Target branch has a harness config file committed; source (main) has it untracked.
+    // Use a path not affected by global gitignore rules (unlike .claude/settings.local.json).
+    git(["checkout", "-b", "milestone/M001"], repo);
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"dark\"}\n");
+    git(["add", ".harness/settings.json"], repo);
+    git(["commit", "-m", "add harness settings"], repo);
+    git(["checkout", "main"], repo);
+
+    mkdirSync(join(repo, ".harness"), { recursive: true });
+    writeFileSync(join(repo, ".harness", "settings.json"), "{\"theme\":\"light\"}\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M001", "test-non-gsd-untracked-collision");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M001");
+    const wtContent = readFileSync(join(repo, ".harness", "settings.json"), "utf8");
+    assert.equal(wtContent, "{\"theme\":\"dark\"}\n");
+    const status = git(["status", "--porcelain"], repo).trim();
+    assert.equal(status, "");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
 });

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -73,4 +73,48 @@ describe("clear stale pending auto-start (#3667)", () => {
       "pending auto-start gate must clear stale map entries for completed discussions",
     );
   });
+
+  test("guided-flow recovers a finished-but-unconsumed discussion instead of dead-ending", () => {
+    // CONTEXT exists + no live turn means the discussion completed but the
+    // agent_end handoff never consumed the entry (e.g. an external-engine
+    // post-hoc gate re-arm wiped the depth verification after the save).
+    // Without recovery, every /gsd prints "Discussion already in progress"
+    // forever: the stale heuristic requires CONTEXT to be absent and
+    // discussPlanComplete requires a ROADMAP that planning never produced.
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("milestoneHasContext && !isAgentTurnInFlight(ctx)"),
+      "pending-entry guard must have a recovery branch for CONTEXT-present, no-turn-in-flight entries",
+    );
+    assert.ok(
+      source.includes("extractDepthVerificationMilestoneId(pendingGateId) === entry.milestoneId"),
+      "recovery must only clear a pending gate belonging to the entry's own milestone",
+    );
+    assert.ok(
+      source.includes("if (checkAutoStartAfterDiscuss(basePath)) return;"),
+      "recovery must re-run the discuss→auto handoff after clearing the stale gate",
+    );
+  });
+
+  test("guided-flow does not treat a live discuss turn as a stale pending entry", () => {
+    const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+    assert.ok(
+      source.includes("!isAgentTurnInFlight(ctx)"),
+      "stale-entry deletion must be gated on no agent turn being in flight — a dispatched " +
+      "discuss turn can think for over 30s before writing its first artifact, and deleting " +
+      "its entry re-dispatches the workflow (duplicate interview + duplicate completion message)",
+    );
+    assert.ok(
+      source.includes('const milestoneHasDraft = !!resolveMilestoneFile(basePath, entry.milestoneId, "CONTEXT-DRAFT");'),
+      "stale-entry check must treat an existing CONTEXT-DRAFT as proof of an in-progress interview",
+    );
+    assert.ok(
+      source.includes("!milestoneHasDraft"),
+      "stale-entry deletion must require the CONTEXT-DRAFT to be absent",
+    );
+    assert.ok(
+      source.includes("ctx.hasPendingMessages"),
+      "in-flight detection must also cover dispatched-but-not-yet-started queued messages",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -472,18 +472,19 @@ test("auto-dispatch needs-attention pause message references /gsd verdict", asyn
   }
 });
 
-test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+test("guidance.ts needs-remediation blocker messages reference /gsd verdict", async () => {
   // We don't need to invoke deriveState — just assert the substring is in the
-  // source. The blocker strings are constructed inline and shipped to the user
-  // verbatim, so a static check is sufficient and avoids fragile DB setup.
-  const stateSource = readFileSync(
-    new URL("../state.ts", import.meta.url).pathname,
+  // source. The blocker strings are constructed in the guidance catalog and
+  // shipped to the user verbatim, so a static check is sufficient and avoids
+  // fragile DB setup.
+  const guidanceSource = readFileSync(
+    new URL("../guidance.ts", import.meta.url).pathname,
     "utf-8",
   );
-  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  const occurrences = guidanceSource.match(/`\/gsd verdict /g) ?? [];
   assert.ok(
     occurrences.length >= 2,
-    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+    `expected at least 2 references to /gsd verdict in guidance.ts blockers, found ${occurrences.length}`,
   );
 });
 

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -258,6 +258,48 @@ describe('complete-slice verification gate (#3580)', () => {
     }
   });
 
+  test('allows a browser UAT declared as a bare keyword under ## UAT Type (M006/S01 format drift)', async () => {
+    // Regression: the agent wrote `## UAT Type\nbrowser-executable` (no
+    // `- UAT mode:` bullet). The old parser defaulted that to artifact-driven
+    // and the gate rejected the slice in a loop.
+    const body = [
+      '## UAT Type',
+      'browser-executable',
+      '',
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    if ('error' in result) {
+      assert.doesNotMatch(
+        result.error,
+        /requires browser verification/i,
+        `bare browser-executable declaration must pass the browser gate, got: ${result.error}`,
+      );
+    }
+  });
+
+  test('explains the missing declaration when a browser UAT has no parseable UAT mode', async () => {
+    // When nothing was declared, the error must not claim the agent
+    // "declared artifact-driven" — it must show the expected bullet format.
+    const body = [
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to reject an undeclared browser UAT');
+    const error = (result as { error: string }).error;
+    assert.match(error, /no parseable UAT mode declaration/i);
+    assert.match(error, /- UAT mode: browser-executable/);
+    assert.doesNotMatch(error, /but declares "UAT mode: artifact-driven"/);
+  });
+
   test('allows a browser UAT when it is declared mixed (mixed receives browser tools)', async () => {
     const body = BROWSER_UAT_BODY.replace('artifact-driven', 'mixed (artifact-driven + browser)');
     const result = await handleCompleteSlice(

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -80,6 +80,20 @@ function createTempProject(): { basePath: string; planPath: string } {
   return { basePath, planPath };
 }
 
+function writeProjectPreferences(basePath: string, yaml: string): void {
+  fs.writeFileSync(path.join(basePath, '.gsd', 'PREFERENCES.md'), `---\n${yaml}---\n`);
+}
+
+async function withWorkingDirectory<T>(cwd: string, action: () => Promise<T>): Promise<T> {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
 function makeValidParams() {
   return {
     taskId: 'T01',
@@ -104,6 +118,13 @@ function makeValidParams() {
   };
 }
 
+function makeEscalationOptions() {
+  return [
+    { id: 'continue', label: 'Continue', tradeoffs: 'Keeps execution moving with the default path.' },
+    { id: 'pause', label: 'Pause', tradeoffs: 'Stops execution until the blocker is reviewed.' },
+  ];
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Fresh DB is migrated to the current schema version
 // ═══════════════════════════════════════════════════════════════════════════
@@ -359,6 +380,105 @@ console.log('\n=== complete-task: handler happy path ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: hard-blocker escalation with mid-execution escalation disabled
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: disabled hard-blocker escalation rolls back completion ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+  writeProjectPreferences(basePath, 'phases:\n  mid_execution_escalation: false\n');
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+  const params = {
+    ...makeValidParams(),
+    blockerDiscovered: true,
+    escalation: {
+      question: 'Should execution pause for the hard blocker?',
+      options: makeEscalationOptions(),
+      recommendation: 'pause',
+      recommendationRationale: 'The blocker should not be silently advanced.',
+      continueWithDefault: false,
+    },
+  };
+
+  const result = await withWorkingDirectory(basePath, () => handleCompleteTask(params, basePath));
+
+  assertTrue('error' in result, 'hard-blocker escalation should fail when escalation handling is disabled');
+  if ('error' in result) {
+    assertMatch(result.error, /hard-blocker escalation/, 'error should mention hard-blocker escalation');
+    assertMatch(result.error, /mid_execution_escalation is disabled/, 'error should mention disabled preference');
+  }
+
+  const task = getTask('M001', 'S01', 'T01');
+  assertTrue(task !== null, 'task row should remain after rollback');
+  assertEq(task!.status, 'pending', 'task status should be rolled back to pending');
+  assertEq(task!.blocker_discovered, true, 'blocker flag should remain recorded for visibility');
+  assertEq(task!.escalation_pending, 0, 'disabled preference should not create a pending escalation flag');
+  assertEq(task!.escalation_awaiting_review, 0, 'disabled preference should not create an awaiting-review flag');
+
+  const adapter = _getAdapter()!;
+  const evRows = adapter.prepare(
+    "SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'"
+  ).all();
+  assertEq(evRows.length, 0, 'verification evidence should be deleted when completion rolls back');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-task: soft escalation with mid-execution escalation disabled
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-task: disabled soft escalation still completes ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const { basePath } = createTempProject();
+  writeProjectPreferences(basePath, 'phases:\n  mid_execution_escalation: false\n');
+
+  insertMilestone({ id: 'M001', title: 'Test Milestone' });
+  insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+  const params = {
+    ...makeValidParams(),
+    escalation: {
+      question: 'Should execution continue with the default?',
+      options: makeEscalationOptions(),
+      recommendation: 'continue',
+      recommendationRationale: 'The default path is safe enough to continue.',
+      continueWithDefault: true,
+    },
+  };
+
+  const result = await withWorkingDirectory(basePath, () => handleCompleteTask(params, basePath));
+
+  assertTrue(!('error' in result), 'soft escalation should still complete when escalation handling is disabled');
+  if (!('error' in result)) {
+    assertTrue(!result.escalation, 'disabled preference should not return escalation metadata');
+  }
+
+  const task = getTask('M001', 'S01', 'T01');
+  assertTrue(task !== null, 'task row should exist');
+  assertEq(task!.status, 'complete', 'soft escalation should leave task complete');
+
+  const adapter = _getAdapter()!;
+  const evRows = adapter.prepare(
+    "SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'"
+  ).all();
+  assertEq(evRows.length, 1, 'verification evidence should remain for soft escalation completion');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-task: Handler validation errors
 // ═══════════════════════════════════════════════════════════════════════════
@@ -414,6 +534,9 @@ console.log('\n=== complete-task: handler idempotency ===');
   // First call should succeed
   const r1 = await handleCompleteTask(params, basePath);
   assertTrue(!('error' in r1), 'first call should succeed');
+  if ('error' in r1) {
+    throw new Error(r1.error);
+  }
 
   // Verify complete-task did not duplicate T01. S01-PLAN.md is a projection,
   // so the remaining plan task is not imported implicitly.
@@ -421,16 +544,29 @@ console.log('\n=== complete-task: handler idempotency ===');
   assertEq(tasks.length, 1, 'should only have the completed DB task after first call');
   assertEq(tasks.filter(t => t.id === 'T01').length, 1, 'should have exactly one T01 row after first call');
 
-  // Second call with same params — state machine guard rejects (task is already complete)
+  // If the DB row is complete but the projection was lost, the duplicate call
+  // should repair the missing summary from full_summary_md instead of forcing a
+  // reopen/re-complete loop.
+  fs.unlinkSync(r1.summaryPath);
+  assertTrue(!fs.existsSync(r1.summaryPath), 'fixture should remove the task summary before repair');
   const r2 = await handleCompleteTask(params, basePath);
-  assertTrue('error' in r2, 'second call should return error (task already complete)');
+  assertTrue(!('error' in r2), 'second call should repair missing summary for DB-complete task');
   if ('error' in r2) {
-    assertMatch(r2.error, /already complete/, 'error should mention already complete');
+    throw new Error(r2.error);
+  }
+  assertTrue(fs.existsSync(r2.summaryPath), 'missing summary should be restored on disk');
+  assertEq(r2.duplicate, true, 'repair should be reported as a duplicate/no-op state mutation');
+
+  // Third call with the summary present — state machine guard rejects (task is already complete)
+  const r3 = await handleCompleteTask(params, basePath);
+  assertTrue('error' in r3, 'third call should return error (task already complete)');
+  if ('error' in r3) {
+    assertMatch(r3.error, /already complete/, 'error should mention already complete');
   }
 
-  // Still no duplicate rows from the rejected second call.
+  // Still no duplicate rows from the repair or rejected third call.
   const tasksAfter = getSliceTasks('M001', 'S01');
-  assertEq(tasksAfter.length, 1, 'should still only have T01 after rejected second call');
+  assertEq(tasksAfter.length, 1, 'should still only have T01 after duplicate repair and rejected third call');
   assertEq(tasksAfter.filter(t => t.id === 'T01').length, 1, 'should still have exactly one T01 row');
 
   cleanupDir(basePath);