@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

package/src/resources/extensions/gsd/tests/doctor-runtime-checks.test.ts

@@ -45,3 +45,30 @@ test("doctor fix respects git.manage_gitignore false (#4161)", async (t) => {
   assert.equal(readFileSync(join(dir, ".gitignore"), "utf-8"), "node_modules/\n");
   assert.equal(existsSync(join(dir, ".gsd", "PREFERENCES.md")), true);
 });
+
+test("doctor fix resets run-uat counters at the dispatch cap", async (t) => {
+  const dir = createGitProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  const runtimeDir = join(dir, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  const counterPath = join(runtimeDir, "uat-count-M002-S01.json");
+  writeFileSync(
+    counterPath,
+    JSON.stringify({ count: 3, updatedAt: "2026-06-02T19:40:23.289Z" }) + "\n",
+    "utf-8",
+  );
+
+  const detect = await runGSDDoctor(dir);
+  const issue = detect.issues.find((candidate) => candidate.code === "uat_retry_exhausted");
+  assert.ok(issue, "doctor reports the exhausted UAT retry counter at the dispatch cap");
+  assert.equal(issue.unitId, "M002/S01");
+  assert.match(issue.message, /3 attempt\(s\)/);
+
+  const fixed = await runGSDDoctor(dir, { fix: true, scope: "M002/S02" });
+  assert.ok(
+    fixed.fixesApplied.some((fix) => fix.includes("reset exhausted run-uat retry counter for M002/S01")),
+    "doctor --fix resets the blocked counter even when the current displayed scope has advanced",
+  );
+  assert.equal(existsSync(counterPath), false);
+});

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -106,7 +106,7 @@ test("ADR-011 P2: writeEscalationArtifact persists canonical JSON at tasks/T##-E
   assert.equal(row?.escalation_artifact_path, path);
 });
 
-test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending) — no pause", (t) => {
+test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending)", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T04");
@@ -126,7 +126,7 @@ test("ADR-011 P2: continueWithDefault=true sets awaiting_review (NOT pending)
   assert.equal(row?.escalation_awaiting_review, 1);
 });
 
-test("ADR-011 P2: detectPendingEscalation returns only pause-scoped escalations", (t) => {
+test("ADR-011 P2: detectPendingEscalation pauses on unresolved awaiting_review escalations", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T01");
@@ -147,7 +147,7 @@ test("ADR-011 P2: detectPendingEscalation returns only pause-scoped escalations"
 
   const tasks = [getTask("M001", "S01", "T01")!, getTask("M001", "S01", "T02")!];
   const id = detectPendingEscalation(tasks, base);
-  assert.equal(id, "T02", "only T02 is pause-worthy; T01 is awaiting_review");
+  assert.equal(id, "T01", "unresolved awaiting_review escalations must pause before later tasks");
 });
 
 test("ADR-011 P2: resolveEscalation(accept) marks artifact + clears flags", (t) => {
@@ -677,26 +677,19 @@ test("ADR-011 P3 #23: concurrent escalations across parallel slices — only the
   assert.equal(detectPendingEscalation([getTask("M001", "S02", "T70")!], base), null);
 });
 
-test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects into the next task dispatched AFTER the response", (t) => {
-  // Timeline this test pins (the "timeout" is implicit — it's just the
-  // elapsed wall-clock where the loop keeps running after T80's
-  // continueWithDefault=true write):
+test("ADR-011 P3 #24: continueWithDefault requires explicit response before override injection", (t) => {
+  // Timeline this test pins:
   //
-  //   1. T80 writes continueWithDefault=true → awaiting_review=1, loop
-  //      continues dispatching T81, T82. Neither claim fires because the
-  //      user has not responded (pins Bug 2 behavior, tested at line 244).
-  //   2. The user responds LATE (after T81/T82 already dispatched).
-  //   3. The very next prompt build (for T83) claims the override exactly
-  //      once. T81/T82 are in the past — they must not retroactively
-  //      receive the injection even though they ran during the window.
+  //   1. T80 writes continueWithDefault=true → awaiting_review=1.
+  //   2. Scheduler detection pauses on T80 instead of treating silence as
+  //      consent. Prompt injection still waits until the user responds.
+  //   3. After the response, the next prompt build claims the override once.
   const base = makeBase();
   t.after(() => cleanup(base));
   seedCompletedTask(base, "T80");
-  seedCompletedTask(base, "T81");
-  seedCompletedTask(base, "T82");
   seedCompletedTask(base, "T83");
 
-  // Phase 1 — T80 escalates with continueWithDefault=true, loop continues.
+  // Phase 1 — T80 escalates with continueWithDefault=true.
   writeEscalationArtifact(base, buildEscalationArtifact({
     taskId: "T80", sliceId: "S01", milestoneId: "M001",
     question: "Which cache strategy?", options: sampleOptions,
@@ -704,21 +697,17 @@ test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects
     continueWithDefault: true,
   }));
 
-  // T80 is awaiting_review (not pending) — scheduler does not pause.
+  // T80 is awaiting_review (not pending), but scheduler detection still
+  // pauses until the user explicitly responds.
   assert.equal(getTask("M001", "S01", "T80")?.escalation_awaiting_review, 1);
   assert.equal(getTask("M001", "S01", "T80")?.escalation_pending, 0);
-  assert.equal(detectPendingEscalation([getTask("M001", "S01", "T80")!], base), null);
+  assert.equal(detectPendingEscalation([getTask("M001", "S01", "T80")!], base), "T80");
 
-  // T81 + T82 dispatch during the response window — neither gets the injection.
+  // Prompt injection must still wait for a response.
   assert.equal(
     claimOverrideForInjection(base, "M001", "S01"),
     null,
-    "T81's prompt build must not claim the unresolved awaiting_review",
-  );
-  assert.equal(
-    claimOverrideForInjection(base, "M001", "S01"),
-    null,
-    "T82's prompt build must also not claim the unresolved awaiting_review",
+    "unresolved awaiting_review must not be claimed as a default response",
   );
 
   // The response window remains open across N tasks — still no override applied.
@@ -728,7 +717,7 @@ test("ADR-011 P3 #24: continueWithDefault timeout — late user response injects
     "applied_at must stay null throughout the response window",
   );
 
-  // Phase 2 — user responds LATE with a different option than the recommendation.
+  // Phase 2 — user responds with a different option than the recommendation.
   const resolveResult = resolveEscalation(
     base, "M001", "S01", "T80", "B", "after reviewing, B is the call",
   );

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -53,6 +53,24 @@ test('runExecSandbox: captures stdout, persists artifacts, returns digest', asyn
   }
 });
 
+test('runExecSandbox: persists optional request metadata', async () => {
+  const base = freshBase();
+  try {
+    const result = await runExecSandbox(
+      {
+        runtime: 'bash',
+        script: 'echo metadata-ok',
+        metadata: { kind: 'uat_exec', intent: 'uat-artifact-check' },
+      },
+      baseOpts(base),
+    );
+    const meta = JSON.parse(readFileSync(result.meta_path, 'utf-8')) as Record<string, unknown>;
+    assert.deepEqual(meta.metadata, { kind: 'uat_exec', intent: 'uat-artifact-check' });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: enforces stdout cap and marks truncation', async () => {
   const base = freshBase();
   try {

package/src/resources/extensions/gsd/tests/exec-tool.test.ts

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { executeUatExec } from "../tools/exec-tool.ts";
+import type { ExecSandboxRequest, ExecSandboxResult } from "../exec-sandbox.ts";
+
+function makeExecResult(request: ExecSandboxRequest): ExecSandboxResult {
+  return {
+    id: "exec-1",
+    runtime: request.runtime,
+    exit_code: 0,
+    signal: null,
+    timed_out: false,
+    duration_ms: 1,
+    stdout_bytes: 12,
+    stderr_bytes: 0,
+    stdout_truncated: false,
+    stderr_truncated: false,
+    stdout_path: ".gsd/exec/exec-1.stdout",
+    stderr_path: ".gsd/exec/exec-1.stderr",
+    meta_path: ".gsd/exec/exec-1.meta.json",
+    digest: "check passed",
+  };
+}
+
+test("executeUatExec accepts evidence-mode aliases for intent", async () => {
+  const requests: ExecSandboxRequest[] = [];
+  const result = await executeUatExec(
+    {
+      milestoneId: "M001",
+      sliceId: "S01",
+      checkId: "UAT-PRE",
+      intent: "artifact",
+      runtime: "bash",
+      script: "printf ok",
+    },
+    {
+      baseDir: "/tmp/gsd-uat-exec-test",
+      preferences: null,
+      run: async (request) => {
+        requests.push(request);
+        return makeExecResult(request);
+      },
+    },
+  );
+
+  assert.equal(result.isError, false);
+  assert.equal(result.details?.operation, "gsd_uat_exec");
+  assert.equal(result.details?.intent, "uat-artifact-check");
+  assert.equal(requests[0]?.metadata?.intent, "uat-artifact-check");
+});
+
+test("registerExecTools exposes gsd_uat_exec intent as recoverable string schema", () => {
+  const tools: Array<{ name: string; parameters: any }> = [];
+  registerExecTools({
+    registerTool: (tool: { name: string; parameters: any }) => {
+      tools.push(tool);
+    },
+  } as any);
+
+  const tool = tools.find((registeredTool) => registeredTool.name === "gsd_uat_exec");
+  assert.ok(tool, "gsd_uat_exec should be registered");
+  const intentSchema = tool.parameters.properties.intent;
+  assert.equal(intentSchema.type, "string");
+  assert.equal("anyOf" in intentSchema, false);
+  assert.match(intentSchema.description, /uat-artifact-check/);
+  assert.match(intentSchema.description, /artifact/);
+});

package/src/resources/extensions/gsd/tests/forensics-issue-routing.test.ts

@@ -41,3 +41,23 @@ test("forensics prompt routes issue creation through bash tool, not github_issue
     "Prompt must instruct use of the bash tool for issue creation",
   );
 });
+
+test("forensics prompt provides paste-once fallback when bash is unavailable", () => {
+  const prompt = readPrompt("forensics");
+
+  assert.match(
+    prompt,
+    /If `bash` is unavailable/i,
+    "Prompt must branch when bash cannot be activated",
+  );
+  assert.match(
+    prompt,
+    /paste-once shell script/i,
+    "Prompt must provide a user-runnable fallback instead of an impossible tool call",
+  );
+  assert.match(
+    prompt,
+    /Searching closed issues for possible duplicates/i,
+    "Fallback script must preserve the duplicate-search step for the user",
+  );
+});

package/src/resources/extensions/gsd/tests/forensics-prompt-rendering.test.ts

@@ -24,13 +24,16 @@ test("forensics prompt renders compact investigation and issue routing guidance"
     forensicData: "stuck-detected event for execute-task/M001/S01/T01",
     gsdSourceDir: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
     dedupSection: "No duplicate issue found.",
+    toolingSection: "## Filing Tool Availability\n\n- `bash`: available\n- `write`: available",
   });
 
   assert.match(prompt, /Investigation Protocol/);
+  assert.match(prompt, /Filing Tool Availability/);
   assert.match(prompt, /gsd_milestone_status/);
   assert.match(prompt, /sqlite3 .gsd\/gsd.db/);
   assert.match(prompt, /gh issue create --repo open-gsd\/gsd-pi/);
   assert.match(prompt, /Do NOT use the `github_issues` tool/);
+  assert.match(prompt, /paste-once shell script/);
   assert.match(prompt, /Redaction Rules/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });

package/src/resources/extensions/gsd/tests/forensics-tool-scope.test.ts

@@ -0,0 +1,69 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies /gsd forensics scopes issue-filing tools for its queued turn.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyForensicsToolScope,
+  buildForensicsToolingSection,
+  createForensicsToolScope,
+  restoreForensicsToolScope,
+} from "../forensics.ts";
+
+function tool(name: string): { name: string } {
+  return { name };
+}
+
+test("forensics adds registered filing tools for the queued turn and restores the prior tools", () => {
+  const originalTools = ["read"];
+  let activeTools = [...originalTools];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "bash", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.savedTools, originalTools);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "bash", "write"]);
+  assert.deepEqual(scope.availableFilingTools, ["bash", "write"]);
+  assert.deepEqual(scope.missingFilingTools, []);
+  assert.equal(scope.toolsChanged, true);
+  assert.deepEqual(activeTools, originalTools, "scope creation must not mutate active tools");
+
+  applyForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, ["read", "bash", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: available/);
+  assert.match(toolingSection, /`write`: available/);
+  assert.match(toolingSection, /GitHub duplicate-check and issue-creation protocols/);
+
+  restoreForensicsToolScope(pi as any, scope);
+  assert.deepEqual(activeTools, originalTools);
+});
+
+test("forensics tooling guidance falls back when bash is not registered", () => {
+  let activeTools = ["read"];
+  const pi = {
+    getActiveTools: () => [...activeTools],
+    getAllTools: () => ["read", "write"].map(tool),
+    setActiveTools: (tools: string[]) => {
+      activeTools = [...tools];
+    },
+  };
+
+  const scope = createForensicsToolScope(pi as any);
+
+  assert.deepEqual(scope.availableFilingTools, ["write"]);
+  assert.deepEqual(scope.missingFilingTools, ["bash"]);
+  assert.deepEqual(scope.activeToolsForTurn, ["read", "write"]);
+
+  const toolingSection = buildForensicsToolingSection(scope);
+  assert.match(toolingSection, /`bash`: unavailable/);
+  assert.match(toolingSection, /paste-once shell script fallback/);
+});

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -1,12 +1,9 @@
 /**
- * gsd-pi / guided-flow — regression tests for Gate 1b orphan discrimination
+ * gsd-pi / guided-flow — regression tests for Gate 1b discussion handoff
  *
- * Gate 1b in checkAutoStartAfterDiscuss discriminates between two "queued" states:
- *   (a) plan-blocked: discuss completed (CONTEXT.md on disk), but gsd_plan_milestone
- *       was hard-blocked by the depth-verification gate.  DB row stuck at "queued".
- *       → emit recovery hint directing the LLM to retry gsd_plan_milestone.
- *   (b) discuss-incomplete: discuss did not finish, no CONTEXT.md, DB row "queued".
- *       → silent block (no recovery hint).
+ * Gate 1b treats queued + pinned CONTEXT.md as Discussion Complete, Planning
+ * Pending. It must accept the handoff without warning the user or injecting a
+ * hidden gsd_plan_milestone retry.
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -27,8 +24,6 @@ import {
   insertMilestone,
 } from "../gsd-db.ts";
 
-// ─── Harness ───────────────────────────────────────────────────────────────
-
 interface MockCapture {
   notifies: Array<{ msg: string; level: string }>;
   messages: Array<{ payload: any; options: any }>;
@@ -58,24 +53,26 @@ function mkPi(cap: MockCapture): any {
   };
 }
 
-/**
- * Create a minimal temp tree with a .gsd/milestones/M001 directory.
- */
 function mkBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   return base;
 }
 
-// ─── Tests ─────────────────────────────────────────────────────────────────
+function writeContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
 
-describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
+describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
 
   beforeEach(() => {
     clearPendingAutoStart();
-    drainLogs(); // discard noise from prior tests
+    drainLogs();
   });
 
   afterEach(() => {
@@ -86,104 +83,59 @@ describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
     }
   });
 
-  test("plan-blocked: CONTEXT.md present + DB row queued → returns false + recovery hint emitted", () => {
+  test("queued row + CONTEXT.md accepts context-captured handoff without hidden retry", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued" (plan_milestone was blocked)
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
-
-    // CONTEXT.md on disk (discuss phase completed)
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
-      "# M001: Test Milestone\n\nContext written by discuss phase.\n",
-    );
+    writeContext(base);
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — auto-start should not proceed
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false (plan still blocked)");
-
-    // Recovery hint must be sent to the LLM
-    assert.equal(
-      cap.messages.length,
-      1,
-      "exactly one sendMessage call expected for the recovery hint",
-    );
-    assert.equal(
-      cap.messages[0].payload.customType,
-      "gsd-plan-milestone-blocked-recovery",
-      "recovery message must have customType gsd-plan-milestone-blocked-recovery",
-    );
+    assert.equal(result, true, "queued + context is a valid planning-pending handoff");
+    assert.equal(cap.messages.length, 0, "must not inject a hidden recovery turn");
+    assert.equal(cap.notifies.length, 1, "must emit one success notification");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
     assert.equal(
-      cap.messages[0].options.triggerTurn,
-      true,
-      "recovery message must set triggerTurn: true",
-    );
-    assert.match(
-      cap.messages[0].payload.content,
-      /gsd_plan_milestone/,
-      "recovery message content must mention gsd_plan_milestone",
+      cap.notifies.some(n => /queued|gsd_plan_milestone/i.test(n.msg)),
+      false,
+      "user-visible copy must not mention queued state or internal plan tool retry",
     );
-
-    // User must be notified via ctx.ui.notify
-    assert.ok(
-      cap.notifies.some((n) => n.level === "warning" && /queued/.test(n.msg)),
-      "user must be notified with a warning about the queued state",
-    );
-
-    // logWarning must have recorded the Gate 1b event
-    const logs = drainLogs();
-    const gate1bLog = logs.find(
-      (e) => e.component === "guided" && /Gate 1b/.test(e.message),
-    );
-    assert.ok(gate1bLog, "Gate 1b warning must be logged via logWarning");
   });
 
-  test("discuss-incomplete: no CONTEXT.md + DB row queued → returns false silently (no recovery hint)", () => {
+  test("queued row without CONTEXT.md still waits silently for discussion output", () => {
     base = mkBase();
     openDatabase(":memory:");
-
-    // DB row exists with status "queued", but NO CONTEXT.md on disk
     insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
 
-    // No CONTEXT.md written — discuss phase is incomplete
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
-    drainLogs(); // clear any noise before the call
+    drainLogs();
 
     const result = checkAutoStartAfterDiscuss();
 
-    // Must return false — silent block
-    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false when discuss is incomplete");
-
-    // No recovery hint — Gate 1 blocks before Gate 1b is reached
-    assert.equal(
-      cap.messages.length,
-      0,
-      "no sendMessage calls expected when CONTEXT.md is absent",
-    );
-    assert.equal(
-      cap.notifies.length,
-      0,
-      "no user notifications expected for discuss-incomplete case",
-    );
+    assert.equal(result, false, "must keep waiting while discuss has not written context");
+    assert.equal(cap.messages.length, 0, "no hidden recovery turn expected");
+    assert.equal(cap.notifies.length, 0, "no user notifications expected");
 
-    // No Gate 1b log entry
     const logs = drainLogs();
     const gate1bLog = logs.find(
       (e) => e.component === "guided" && /Gate 1b/.test(e.message),