@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -6,7 +6,11 @@ import assert from "node:assert/strict";
 
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitToolContract } from "../tool-contract.js";
+import {
+  compileUnitContextContract,
+  compileUnitToolContract,
+  getUnitWorkflowDispatchReadinessError,
+} from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
@@ -63,11 +67,27 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
 
   assert.equal(result.ok, true);
   assert.equal(result.ok && result.contract.unitType, "execute-task");
-  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, ["gsd_task_complete"]);
+  assert.deepEqual(result.ok && result.contract.requiredWorkflowTools, [
+    "gsd_task_complete",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_capture_thought",
+  ]);
   assert.deepEqual(result.ok && result.contract.forbiddenWorkflowTools, []);
   assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
   assert.ok(result.ok && result.contract.validationRules.includes("closeout-tool-present"));
   assert.ok(result.ok && result.contract.validationRules.includes("source-observation-contract-present"));
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.inline, [
+    "task-plan",
+    "slice-plan",
+    "prior-task-summaries",
+    "templates",
+  ]);
+  assert.deepEqual(result.ok && result.contract.promptContext.artifacts.onDemand, ["slice-research"]);
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-inline:task-plan,slice-plan,prior-task-summaries,templates"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("context-on-demand:slice-research"));
+  assert.ok(result.ok && result.contract.promptObligations.includes("source-observations:whole-file-active-unit"));
   assert.deepEqual(result.ok && result.contract.sourceObservations, {
     mode: "whole-file-active-unit",
     seedFields: ["task.files", "task.inputs"],
@@ -77,6 +97,34 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
 
+test("Tool Contract derives dispatch readiness from Unit workflow tools", () => {
+  const error = getUnitWorkflowDispatchReadinessError({
+    provider: "claude-code",
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+  });
+
+  assert.equal(error, null);
+});
+
+test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
+  const result = compileUnitContextContract("execute-task");
+
+  assert.equal(result.ok, true);
+  assert.equal(result.ok && result.contract.unitType, "execute-task");
+  assert.equal(result.ok && result.contract.contextMode, "execution");
+  assert.equal(result.ok && result.contract.toolsPolicy.mode, "all");
+  assert.deepEqual(result.ok && result.contract.artifacts.excerpt, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.computed, []);
+  assert.deepEqual(result.ok && result.contract.artifacts.prepend, []);
+  assert.equal(result.ok && result.contract.maxSystemPromptChars, 1_500_000);
+  assert.equal(result.ok && result.contract.sourceObservations.mode, "whole-file-active-unit");
+});
+
 test("Tool Contract records high-risk cross-phase tool boundaries without single-owning every tool", () => {
   const completeSlice = compileUnitToolContract("complete-slice");
   const runUat = compileUnitToolContract("run-uat");
@@ -140,6 +188,7 @@ test("Recovery Classification covers ADR-015 failure families", () => {
   const cases = [
     ["invalid tool schema enum", "tool-schema", "stop"],
     ["Tool Contract failure: complete-slice cannot use gsd_uat_result_save", "tool-contract", "stop"],
+    ["No such tool available: mcp__gsd-workflow__gsd_uat_exec", "tool-unavailable", "retry"],
     ["deterministic policy rejection", "deterministic-policy", "stop"],
     ["cannot legally advance because required UAT Assessment artifact is missing", "lifecycle-progression", "stop"],
     ["stale worker lease", "stale-worker", "stop"],

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -266,3 +266,41 @@ test("safety-harness: planned changed file avoids unexpected-file warning", (t)
   assert.deepEqual(audit!.unexpectedFiles, [], "planned index.html must not be unexpected");
   assert.deepEqual(audit!.missingFiles, [], "planned index.html must not be missing");
 });
+
+// ─── External engine evidence (claude-code-cli pre-executed tools) ──────────
+// External engines skip beforeToolCall/tool_call, so register-hooks.ts records
+// evidence at tool_execution_start instead. These tests lock the collector
+// semantics that wiring relies on: idempotent recording by toolCallId, and
+// capitalized external tool names (Bash/Write/Edit) being recognized.
+
+test("safety-harness: recordToolCall is idempotent by toolCallId", () => {
+  resetEvidence();
+
+  // Native tools fire tool_execution_start AND tool_call — both record.
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+  recordToolCall("tc-dup-1", "bash", { command: "npm test" });
+
+  assert.equal(getEvidence().length, 1, "same toolCallId must not duplicate");
+});
+
+test("safety-harness: external capitalized Bash call records and resolves evidence", () => {
+  resetEvidence();
+
+  // tool_execution_start with Claude Code's native tool name
+  recordToolCall("ext-bash-1", "Bash", { command: "node /tmp/t01-verify.mjs" });
+  const entries = getEvidence().filter((e): e is BashEvidence => e.kind === "bash");
+  assert.equal(entries.length, 1, "capitalized Bash must be recognized as execution tool");
+  assert.equal(entries[0]!.command, "node /tmp/t01-verify.mjs");
+
+  // tool_execution_end fills the result
+  recordToolResult("ext-bash-1", "Bash", { content: [{ type: "text", text: "13 checks passed" }] }, false);
+  assert.equal(entries[0]!.exitCode, 0, "non-error external result resolves to exitCode 0");
+});
+
+test("safety-harness: external Write call records file evidence", () => {
+  resetEvidence();
+
+  recordToolCall("ext-write-1", "Write", { file_path: "/tmp/app/index.html" });
+  const writes = getEvidence().filter((e) => e.kind === "write");
+  assert.equal(writes.length, 1, "capitalized Write must record file evidence");
+});

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -24,6 +24,7 @@ import { fileURLToPath } from "node:url";
 
 import { autoSession } from "../auto-runtime-state.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { _resetPreferenceDiagnosticNotificationsForTests } from "../preferences-diagnostics.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const HOOKS_SOURCE = readFileSync(
@@ -485,3 +486,82 @@ test("session_start and session_switch apply disabled model provider policy from
     "session_switch should re-read preferences for the switched project/session context",
   );
 });
+
+test("session_start surfaces malformed preference diagnostics through visible notifications", async (t) => {
+  const dir = join(
+    tmpdir(),
+    `gsd-session-pref-diagnostics-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const tempGsdHome = join(dir, "home");
+  mkdirSync(tempGsdHome, { recursive: true });
+
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(dir);
+  _resetPreferenceDiagnosticNotificationsForTests();
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    _resetPreferenceDiagnosticNotificationsForTests();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  });
+
+  writeFileSync(
+    join(dir, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "version: 1",
+      "models:",
+      "  validation:",
+      "    openrouter/deepseek/deepseek-v4-pro",
+      "    thinking: high",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const notifications: Array<{ message: string; level?: string }> = [];
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+  const ctx = {
+    hasUI: true,
+    ui: {
+      notify: (message: string, level?: string) => notifications.push({ message, level }),
+      setStatus: () => {},
+      setFooter: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: () => {},
+    },
+    sessionManager: { getSessionId: () => null },
+    model: null,
+    setCompactionThresholdOverride: () => {},
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => false,
+    },
+  };
+
+  registerHooks(pi, []);
+
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler must be registered");
+  await sessionStart!({}, ctx);
+
+  const diagnostic = notifications.find((notification) =>
+    notification.message.includes("GSD project preferences error"),
+  );
+  assert.equal(diagnostic?.level, "error");
+  assert.match(diagnostic?.message ?? "", /could not be parsed/);
+  assert.match(diagnostic?.message ?? "", /line 5, column 5/);
+  assert.match(diagnostic?.message ?? "", /Preferences from this file were ignored/);
+});

package/src/resources/extensions/gsd/tests/session-switch-clears-pending-autostart.test.ts

@@ -0,0 +1,108 @@
+// gsd-pi — A fresh conversation (/clear, /new) must clear pending auto-start.
+//
+// The discuss→auto handoff entry lives in-memory and is consumed on agent_end
+// of the live interview. Once the milestone CONTEXT artifact is saved, the
+// guided-flow staleness heuristic (which requires the CONTEXT file to be
+// absent) can never fire — so a discussion interrupted by /clear left an
+// immortal entry and every subsequent /gsd dead-ended on "Discussion already
+// in progress — answer the question above" with no question above.
+//
+// session_switch with reason "new" means the conversation that contained the
+// interview is gone; the entry must go with it. Reason "resume" restores the
+// interview transcript, so the entry must survive.
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  _getPendingAutoStart,
+} from "../pending-auto-start.ts";
+
+function makeProjectDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-switch-pas-"));
+  const milestoneDir = join(dir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  // The post-CONTEXT state that made the entry immortal before the fix.
+  writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# M001 Context\n");
+  return dir;
+}
+
+function fakeCtx(base: string): any {
+  return {
+    cwd: base,
+    ui: {
+      notify: () => undefined,
+      setWidget: () => undefined,
+      setStatus: () => undefined,
+    },
+  };
+}
+
+function armPendingAutoStart(base: string): void {
+  setPendingAutoStart(base, {
+    basePath: base,
+    milestoneId: "M001",
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  });
+}
+
+describe("session_switch clears pending auto-start on conversation reset", () => {
+  let base: string;
+  const handlers = new Map<string, Function>();
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    base = makeProjectDir();
+    handlers.clear();
+    registerHooks({ on(event: string, handler: Function) { handlers.set(event, handler); } } as any, []);
+  });
+
+  afterEach(() => {
+    clearPendingAutoStart();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  async function fireSessionSwitch(reason: "new" | "resume"): Promise<void> {
+    const handler = handlers.get("session_switch");
+    assert.ok(handler, "session_switch handler should be registered");
+    try {
+      await handler({ type: "session_switch", reason, previousSessionFile: undefined }, fakeCtx(base));
+    } catch {
+      // The handler also performs session plumbing (MCP prep, service tier
+      // sync) that may throw against the minimal fake ctx. Pending auto-start
+      // is cleared before that plumbing runs, so the assertions below remain
+      // valid either way.
+    }
+  }
+
+  it('reason "new" (/clear, /new) drops the entry even after CONTEXT was saved', async () => {
+    armPendingAutoStart(base);
+    assert.ok(_getPendingAutoStart(base), "entry should be armed");
+
+    await fireSessionSwitch("new");
+
+    assert.equal(
+      _getPendingAutoStart(base),
+      null,
+      "a fresh conversation destroyed the interview — the handoff entry must not outlive it",
+    );
+  });
+
+  it('reason "resume" keeps the entry (the interview transcript is restored)', async () => {
+    armPendingAutoStart(base);
+
+    await fireSessionSwitch("resume");
+
+    assert.ok(
+      _getPendingAutoStart(base),
+      "resuming restores the interview — the in-flight handoff must survive",
+    );
+  });
+});