@opengsd/gsd-pi 1.2.0-dev.4c756166 → 1.2.0-dev.822c9439

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

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Doctor git checks treat validation-pass closeout as terminal without SUMMARY.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { openDatabase, insertMilestone, insertSlice, insertAssessment, closeDatabase } from "../gsd-db.js";
+import { createWorktree, worktreePath } from "../worktree-manager.ts";
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-terminal-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, "package.json"), "{\"scripts\":{}}\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+  return base;
+}
+
+test.after(() => {
+  closeDatabase();
+});
+
+test("doctor flags orphaned worktree for DB-complete milestone without SUMMARY", async (t) => {
+  const base = makeRepo();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M008", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: worktree\n---\n",
+  );
+  mkdirSync(join(base, ".gsd", "milestones", "M008"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M008", "M008-ROADMAP.md"),
+    "# M008 Roadmap\n\n- [x] **S01: Slice** `risk:low` `depends:[]`\n",
+  );
+
+  createWorktree(base, "M008", { branch: "milestone/M008" });
+  const wtPath = worktreePath(base, "M008");
+  assert.ok(existsSync(wtPath), "worktree should exist for the test");
+
+  const report = await runGSDDoctor(base, { isolationMode: "worktree" });
+
+  assert.ok(
+    report.issues.some((issue) => issue.code === "orphaned_auto_worktree" && issue.unitId === "M008"),
+    "doctor should treat DB-complete milestone without SUMMARY as terminal for cleanup",
+  );
+});

package/src/resources/extensions/gsd/tests/dynamic-bash-no-cap.test.ts

@@ -0,0 +1,132 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createBashTool } from "@gsd/pi-coding-agent";
+
+import { registerDynamicTools } from "../bootstrap/dynamic-tools.ts";
+import { createAsyncBashTool } from "../../async-jobs/async-bash-tool.ts";
+
+// These tests assert on the runtime tool objects the agent actually receives —
+// the registered GSD bash tool, the core bash tool, and the async_bash tool —
+// not on source text. The behavioral guarantee (an explicit timeout still
+// fires after the silent 120s cap was removed) is exercised by spawning a real
+// process at the bottom of the file.
+
+/** Capture the GSD-registered `bash` tool object from registerDynamicTools. */
+function registerAndCaptureBash(): any {
+  let captured: any = undefined;
+  const pi = {
+    registerTool: (tool: any) => {
+      if (!captured && tool && tool.name === "bash") captured = tool;
+    },
+  };
+  registerDynamicTools(pi as any);
+  assert.ok(captured, "registerDynamicTools must register a tool named 'bash'");
+  return captured;
+}
+
+// 1. Cap removal: the GSD bash tool no longer injects a default timeout. The
+//    schema's timeout stays optional (no `default`), so an omitted timeout
+//    means "no timeout" rather than a silent 120s cap.
+test("GSD bash tool exposes an optional timeout with no injected default", () => {
+  const bash = registerAndCaptureBash();
+  const timeout = bash.parameters?.properties?.timeout;
+  assert.ok(timeout, "bash tool must expose a `timeout` parameter");
+  assert.equal(
+    "default" in timeout,
+    false,
+    "the timeout schema must not carry a default — an omitted timeout means uncapped",
+  );
+  assert.equal(
+    bash.parameters?.required?.includes?.("timeout") ?? false,
+    false,
+    "timeout must remain optional",
+  );
+});
+
+// 2. Watchdog verbiage is GSD-scoped: the core bash tool (reused by non-GSD
+//    embeddings with no watchdog) must NOT claim a watchdog, while the
+//    GSD-registered tool injects it into both description and timeout schema.
+test("core bash tool does not advertise the auto-mode watchdog", () => {
+  const core = createBashTool(process.cwd(), { spawnHook: (c: any) => c });
+  assert.equal(
+    /stalled-tool watchdog/.test(core.description ?? ""),
+    false,
+    "core bash must not advertise a watchdog — non-GSD embeddings have none",
+  );
+  assert.equal(
+    /stalled-tool watchdog/.test(
+      (core.parameters as any)?.properties?.timeout?.description ?? "",
+    ),
+    false,
+    "core bash timeout schema must not advertise a watchdog",
+  );
+});
+
+test("GSD-registered bash tool advertises the stalled-tool watchdog", () => {
+  const bash = registerAndCaptureBash();
+  assert.equal(
+    /stalled-tool watchdog/.test(bash.description ?? ""),
+    true,
+    "the GSD bash description must name the stalled-tool watchdog",
+  );
+  assert.equal(
+    /stalled-tool watchdog/.test(
+      bash.parameters?.properties?.timeout?.description ?? "",
+    ),
+    true,
+    "the GSD bash timeout schema must name the stalled-tool watchdog",
+  );
+});
+
+// 3. async_bash guidance frames itself as a non-blocking/background choice and
+//    no longer implies sync bash is time-capped.
+test("async_bash guidance is non-blocking and drops the sync-cap implication", () => {
+  const asyncTool: any = createAsyncBashTool(
+    () => ({ register: () => "job-0" }) as any,
+    () => process.cwd(),
+  );
+  const guidance = (asyncTool.promptGuidelines ?? []).join("\n");
+  assert.equal(
+    /more than a few seconds/.test(guidance),
+    false,
+    "async_bash guidance must not imply sync bash is time-capped",
+  );
+  assert.equal(
+    /non-blocking/.test(guidance),
+    true,
+    "async_bash guidance must describe itself as non-blocking",
+  );
+});
+
+// 4. Behavioral passthrough: an explicitly-set timeout is still honored after
+//    the cap removal. A 1s timeout on a 5s sleep must fire well under 5s.
+test("GSD bash still forwards an explicit timeout (cap removal did not break passthrough)", async () => {
+  const bash = registerAndCaptureBash();
+
+  const start = Date.now();
+  let resultText = "";
+  try {
+    const result: any = await bash.execute(
+      "t1",
+      { command: "sleep 5", timeout: 1 },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+    resultText = JSON.stringify(result ?? "");
+  } catch (err) {
+    resultText = String(err instanceof Error ? err.message : err);
+  }
+  const elapsed = Date.now() - start;
+
+  assert.equal(
+    /timed out|timeout|exited with code|force-killed/i.test(resultText),
+    true,
+    `explicit 1s timeout should fire before the 5s sleep completes; got: ${resultText}`,
+  );
+  assert.ok(
+    elapsed < 4500,
+    `explicit timeout should fire quickly, not run to completion (elapsed ${elapsed}ms)`,
+  );
+});

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

@@ -0,0 +1,148 @@
+// Engine hook contract: which tool lifecycle hooks fire under which engine,
+// and the consolidated tool-name normalizer seam.
+//
+// 1. Pins the contract arrays (engine-hook-contract.ts) so a change to the
+//    fire matrix is a deliberate, reviewed act.
+// 2. Source-scans register-hooks.ts (in the style of
+//    single-writer-invariant.test.ts) to assert that the concerns documented
+//    as universally mirrored — evidence collection and write-gate (re-)arming —
+//    actually live inside a tool_execution_start handler, not only in the
+//    native-only tool_call handlers.
+// 3. Pins normalizer parity: canonicalHeadlessToolName delegates to
+//    canonicalToolName (strip-only), and canonicalWorkflowToolName adds alias
+//    resolution on top of the same strip.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  UNIVERSAL_TOOL_HOOKS,
+  NATIVE_ONLY_TOOL_HOOKS,
+  canonicalToolName,
+  canonicalWorkflowToolName,
+} from "../engine-hook-contract.js";
+import { canonicalHeadlessToolName } from "../../../../headless-events.js";
+import { WORKFLOW_TOOL_ALIAS_PAIRS } from "../workflow-tool-surface.js";
+
+test("contract arrays pin the verified fire matrix", () => {
+  assert.deepEqual([...UNIVERSAL_TOOL_HOOKS], ["tool_execution_start", "tool_execution_end"]);
+  assert.deepEqual([...NATIVE_ONLY_TOOL_HOOKS], ["tool_call", "tool_result"]);
+});
+
+// ---------------------------------------------------------------------------
+// Source scan: register-hooks.ts must mirror safety concerns universally
+// ---------------------------------------------------------------------------
+
+const registerHooksSource = readFileSync(
+  join(process.cwd(), "src/resources/extensions/gsd/bootstrap/register-hooks.ts"),
+  "utf8",
+);
+
+/**
+ * Extract the body of every `pi.on("<eventName>", ...)` registration by
+ * scanning balanced parentheses from each registration site.
+ */
+function hookBodies(source: string, eventName: string): string[] {
+  const bodies: string[] = [];
+  const marker = `pi.on("${eventName}"`;
+  let from = 0;
+  for (;;) {
+    const start = source.indexOf(marker, from);
+    if (start < 0) break;
+    let depth = 0;
+    let end = -1;
+    // Scan from pi.on's own opening paren so the whole registration is balanced.
+    for (let i = start + "pi.on".length; i < source.length; i++) {
+      const ch = source[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    assert.ok(end > start, `unbalanced pi.on("${eventName}") registration`);
+    bodies.push(source.slice(start, end + 1));
+    from = end + 1;
+  }
+  return bodies;
+}
+
+test("tool_execution_start handler mirrors evidence collection and write-gate arming", () => {
+  const bodies = hookBodies(registerHooksSource, "tool_execution_start");
+  assert.ok(bodies.length >= 1, "register-hooks.ts must register a tool_execution_start handler");
+  const merged = bodies.join("\n");
+
+  // Evidence collection: the safety harness records the call on the universal
+  // hook (deduped by toolCallId against the native-only tool_call recording).
+  assert.match(merged, /safetyRecordToolCall\(/);
+  assert.match(merged, /saveEvidenceToDisk\(/);
+
+  // Write-gate (re-)arming: external engines never reach the tool_call
+  // deferApprovalGate path, so the durable pending gate must be armed here.
+  assert.match(merged, /hostWriteGateAdapter\.setPending\(/);
+});
+
+test("mirrored concerns also exist on the native-only tool_call side (dedup pairing)", () => {
+  const bodies = hookBodies(registerHooksSource, "tool_call");
+  assert.ok(bodies.length >= 1, "register-hooks.ts must register tool_call handlers");
+  const merged = bodies.join("\n");
+  assert.match(merged, /safetyRecordToolCall\(/);
+  assert.match(merged, /deferApprovalGate\(/);
+});
+
+test("tool_execution_end handler mirrors error classification and evidence persistence", () => {
+  const bodies = hookBodies(registerHooksSource, "tool_execution_end");
+  assert.ok(bodies.length >= 1, "register-hooks.ts must register a tool_execution_end handler");
+  const merged = bodies.join("\n");
+  assert.match(merged, /recordToolInvocationError\(/);
+  assert.match(merged, /safetyRecordToolResult\(/);
+});
+
+// ---------------------------------------------------------------------------
+// Normalizer parity
+// ---------------------------------------------------------------------------
+
+test("canonicalHeadlessToolName matches canonicalToolName on the edge-case table", () => {
+  const cases: Array<{ input: string; expected: string }> = [
+    { input: "mcp__server__tool", expected: "tool" },
+    { input: "mcp__gsd-workflow__gsd_status", expected: "gsd_status" },
+    { input: "plain", expected: "plain" },
+    { input: "ask_user_questions", expected: "ask_user_questions" },
+    // Nested underscores: only the first server/tool delimiter splits.
+    { input: "mcp__s__a__b", expected: "a__b" },
+    { input: "", expected: "" },
+    { input: "mcp__", expected: "mcp__" },
+    // Malformed names stay unchanged (strict parser: empty server/tool → no strip).
+    { input: "mcp____tool", expected: "mcp____tool" },
+    { input: "mcp__server__", expected: "mcp__server__" },
+  ];
+  for (const { input, expected } of cases) {
+    assert.equal(canonicalToolName(input), expected, `canonicalToolName(${JSON.stringify(input)})`);
+    assert.equal(
+      canonicalHeadlessToolName(input),
+      canonicalToolName(input),
+      `headless/strip parity for ${JSON.stringify(input)}`,
+    );
+  }
+  assert.equal(canonicalHeadlessToolName(undefined), "");
+});
+
+test("canonicalWorkflowToolName = prefix strip + workflow alias resolution", () => {
+  // Non-alias names behave exactly like canonicalToolName.
+  for (const name of ["mcp__server__tool", "plain", "mcp__s__a__b"]) {
+    assert.equal(canonicalWorkflowToolName(name), canonicalToolName(name));
+  }
+  // Alias names additionally resolve to the canonical workflow tool.
+  assert.ok(WORKFLOW_TOOL_ALIAS_PAIRS.length > 0, "expected at least one workflow alias");
+  for (const { alias, canonical } of WORKFLOW_TOOL_ALIAS_PAIRS) {
+    assert.equal(canonicalWorkflowToolName(alias), canonical);
+    assert.equal(canonicalWorkflowToolName(`mcp__gsd-workflow__${alias}`), canonical);
+    // Plain strip must NOT resolve aliases — that distinction is the seam.
+    assert.equal(canonicalToolName(alias), alias);
+  }
+});

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

@@ -0,0 +1,157 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for evidence cross-referencing of gsd_exec /
+// gsd_uat_exec tool calls. Mirrors the live false-positive where an
+// execute-task agent ran its verification commands through gsd_exec (script
+// body in the `script` argument) and the cross-referencer reported
+// "No bash tool call found" despite successful execution.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  resetEvidence,
+  getEvidence,
+  recordToolCall,
+  recordToolResult,
+  isExecutionToolName,
+  type BashEvidence,
+} from "../safety/evidence-collector.ts";
+import { crossReferenceEvidence } from "../safety/evidence-cross-ref.ts";
+
+function gsdExecResult(exitCode: number, id = "4858202d-2ed7-4a0a-9ef7-4e159e65da83"): unknown {
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        operation: "gsd_exec",
+        id,
+        runtime: "bash",
+        exit_code: exitCode,
+        signal: null,
+        timed_out: false,
+        duration_ms: 272,
+        stdout_bytes: 592,
+        stderr_bytes: 0,
+        meta_path: `/tmp/does-not-exist/.gsd/exec/${id}.meta.json`,
+      }),
+    }],
+  };
+}
+
+test("evidence-xref: verification run through gsd_exec script matches the claimed command", () => {
+  resetEvidence();
+
+  // The live false positive: agent runs `node --test tests/verify-s01.test.js`
+  // inside a gsd_exec script with a cd prefix and exit-code echo suffix.
+  recordToolCall("tc-exec-1", "gsd_exec", {
+    script: 'cd /work/.gsd/worktrees/M001 && node --test tests/verify-s01.test.js; echo "EXIT=$?"',
+    purpose: "T02: run node --test contract checks against T01 index.html",
+  });
+  recordToolResult("tc-exec-1", "gsd_exec", gsdExecResult(0), false);
+
+  const mismatches = crossReferenceEvidence(
+    [{ command: "node --test tests/verify-s01.test.js", exitCode: 0, verdict: "passed" }],
+    getEvidence(),
+  );
+
+  assert.deepEqual(mismatches, [], "gsd_exec-executed verification must not be flagged as missing");
+});
+
+test("evidence-xref: multi-line gsd_exec script matches claims for each embedded command", () => {
+  resetEvidence();
+
+  recordToolCall("tc-exec-2", "gsd_exec", {
+    script: [
+      "cd /work/.gsd/worktrees/M001",
+      "sed -i '' \"s/'todos'/'tasks-v1'/\" index.html",
+      "node --test tests/verify-s01.test.js > /dev/null 2>&1",
+      'echo "BROKEN_EXIT=$?"',
+    ].join("\n"),
+    purpose: "T02: deliberate contract break must fail, then restore",
+  });
+  recordToolResult("tc-exec-2", "gsd_exec", gsdExecResult(0), false);
+
+  const mismatches = crossReferenceEvidence(
+    [{ command: "node --test tests/verify-s01.test.js > /dev/null 2>&1", exitCode: 0, verdict: "passed" }],
+    getEvidence(),
+  );
+
+  assert.deepEqual(mismatches, [], "command embedded in a multi-line script must match");
+});
+
+test("evidence-xref: claimed pass with failing gsd_exec exit_code is still an error", () => {
+  resetEvidence();
+
+  recordToolCall("tc-exec-3", "gsd_exec", {
+    script: "node --test tests/verify-s01.test.js",
+    purpose: "verification",
+  });
+  // gsd_exec reports failures via the JSON envelope's exit_code (and isError).
+  recordToolResult("tc-exec-3", "gsd_exec", gsdExecResult(1), true);
+
+  const mismatches = crossReferenceEvidence(
+    [{ command: "node --test tests/verify-s01.test.js", exitCode: 0, verdict: "passed" }],
+    getEvidence(),
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "error");
+  assert.match(mismatches[0].reason, /Claimed exitCode=0 but actual exitCode=1/);
+});
+
+test("evidence-collector: gsd_uat_exec and MCP-namespaced variants are execution tools", () => {
+  assert.equal(isExecutionToolName("gsd_uat_exec"), true);
+  assert.equal(isExecutionToolName("mcp__gsd-workflow__gsd_uat_exec"), true);
+  assert.equal(isExecutionToolName("mcp__gsd-workflow__gsd_exec"), true);
+
+  resetEvidence();
+  recordToolCall("tc-uat-1", "gsd_uat_exec", { script: "curl -fsS http://localhost:3000/health" });
+  const bash = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(bash.length, 1, "gsd_uat_exec must record bash evidence");
+  assert.equal(bash[0].command, "curl -fsS http://localhost:3000/health");
+});
+
+test("evidence-xref: blank-command evidence does not satisfy arbitrary claims", () => {
+  // Before script extraction existed, gsd_exec calls were recorded with
+  // command: "" — and `"x".includes("")` made them match every claim,
+  // masking genuine fabrications. Blank entries must never match.
+  const mismatches = crossReferenceEvidence(
+    [{ command: "node --test tests/verify-s01.test.js", exitCode: 0, verdict: "passed" }],
+    [{
+      kind: "bash",
+      toolCallId: "tc-blank",
+      command: "",
+      exitCode: 0,
+      outputSnippet: "",
+      timestamp: 1,
+    }],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "warning");
+  assert.match(mismatches[0].reason, /No bash tool call found/);
+});
+
+test("evidence-collector: exit code falls back to .gsd/exec meta.json when result text omits it", (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-exec-meta-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  const metaPath = join(dir, "run-1.meta.json");
+  writeFileSync(metaPath, JSON.stringify({ id: "run-1", exit_code: 7 }));
+
+  resetEvidence();
+  recordToolCall("tc-meta-1", "gsd_exec", { script: "exit 7" });
+  // Truncated result: meta_path survives but exit_code was cut off.
+  recordToolResult(
+    "tc-meta-1",
+    "gsd_exec",
+    { content: [{ type: "text", text: `{"operation":"gsd_exec","meta_path":${JSON.stringify(metaPath)}` }] },
+    false,
+  );
+
+  const bash = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(bash[0].exitCode, 7, "exit code must be recovered from meta.json");
+});