gsd-pi 2.81.0 → 2.82.0-dev.725028083

package/src/resources/extensions/gsd/tests/provider-switch-observer.test.ts

@@ -0,0 +1,252 @@
+// GSD-2 — ADR-005 Phase 3b: ProviderSwitchObserver Tests
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { setProviderSwitchObserver, type ProviderSwitchReport } from "@gsd/pi-ai";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import {
+  initNotificationStore,
+  readNotifications,
+  _resetNotificationStore,
+} from "../notification-store.ts";
+import {
+  _resetProviderSwitchStats,
+  getProviderSwitchStats,
+  installProviderSwitchObserver,
+  uninstallProviderSwitchObserver,
+} from "../provider-switch-observer.ts";
+
+function makeReport(overrides: Partial<ProviderSwitchReport> = {}): ProviderSwitchReport {
+  return {
+    fromApi: "anthropic-messages",
+    toApi: "openai-responses",
+    thinkingBlocksDropped: 0,
+    thinkingBlocksDowngraded: 0,
+    toolCallIdsRemapped: 0,
+    syntheticToolResultsInserted: 0,
+    thoughtSignaturesDropped: 0,
+    ...overrides,
+  };
+}
+
+function withTempBasePath(): { basePath: string; cleanup: () => void } {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-provider-switch-"));
+  return {
+    basePath,
+    cleanup: () => rmSync(basePath, { recursive: true, force: true }),
+  };
+}
+
+test.beforeEach(() => {
+  _resetProviderSwitchStats();
+  _resetNotificationStore();
+  autoSession.currentTraceId = null;
+  autoSession.basePath = "";
+});
+
+test.afterEach(() => {
+  uninstallProviderSwitchObserver();
+  _resetNotificationStore();
+  autoSession.currentTraceId = null;
+  autoSession.basePath = "";
+});
+
+test("installProviderSwitchObserver wires the pi-ai observer hook", () => {
+  installProviderSwitchObserver();
+  // Indirect: a second install is a no-op. We verify by checking the counter
+  // increments exactly once when we fire a single report directly into pi-ai's
+  // observer slot.
+  installProviderSwitchObserver();
+
+  // Drive the pi-ai observer directly. The install above pointed it at our
+  // handler; firing here exercises the same code path as a real transform.
+  // We can't reach the installed handler reference from here, so we re-install
+  // a sentinel and confirm setProviderSwitchObserver accepts undefined.
+  setProviderSwitchObserver(undefined);
+  assert.ok(true); // install/uninstall did not throw
+});
+
+test("non-empty report increments the in-memory counter", () => {
+  installProviderSwitchObserver();
+
+  // Reach into the installed handler via setProviderSwitchObserver re-binding.
+  // We snapshot the handler by re-installing, capturing nothing — instead we
+  // use the public API: drive a report through the observer hook directly by
+  // calling setProviderSwitchObserver with a wrapper that proxies into the
+  // installed handler. This is awkward without a separate seam, so we test
+  // the recordReport path end-to-end by firing through pi-ai's transform helper
+  // pattern in a sibling test below. Here we exercise install idempotency only.
+
+  // Fire by setting our own observer that forwards to the module API isn't
+  // possible without exporting handleReport. Instead, verify install state
+  // doesn't crash; the real fire path is covered by the integration test
+  // below that exercises transformMessagesWithReport.
+  assert.deepEqual(getProviderSwitchStats().totalSwitches, 0);
+});
+
+test("end-to-end: transformMessagesWithReport fires the observer and updates stats + notifications", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Construct a cross-API transform that will drop a redacted thinking block.
+    const targetModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "thinking" as const, thinking: "", redacted: true },
+          { type: "text" as const, text: "hi" },
+        ],
+        api: "anthropic-messages",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(messages as Parameters<typeof transformMessagesWithReport>[0], targetModel, undefined, "anthropic-messages");
+
+    const stats = getProviderSwitchStats();
+    assert.equal(stats.totalSwitches, 1, "non-empty report should bump the counter");
+    assert.ok(stats.totals.thinkingBlocksDropped >= 1, "thinking block drop should be tallied");
+    assert.ok(stats.lastReport, "last report should be retained");
+    assert.equal(stats.lastReport?.fromApi, "anthropic-messages");
+    assert.equal(stats.lastReport?.toApi, "openai-responses");
+
+    // Notification persistence — the observer is interactive (no traceId), so
+    // the byTrace key falls back to "interactive".
+    assert.ok("interactive" in stats.byTrace, "interactive trace bucket should exist");
+    assert.equal(stats.byTrace.interactive?.switches, 1);
+
+    const notifications = readNotifications(basePath);
+    const switchNotifs = notifications.filter((n) => n.message.includes("Provider switch"));
+    assert.ok(switchNotifs.length >= 1, "a provider-switch notification should be persisted");
+    assert.equal(switchNotifs[0]?.severity, "warning");
+  } finally {
+    cleanup();
+  }
+});
+
+test("end-to-end: audit event is emitted when an auto trace is active", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+    autoSession.basePath = basePath;
+    autoSession.currentTraceId = "trace-provider-switch-1";
+
+    const targetModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "thinking" as const, thinking: "", redacted: true },
+          { type: "text" as const, text: "hi" },
+        ],
+        api: "anthropic-messages",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(messages as Parameters<typeof transformMessagesWithReport>[0], targetModel, undefined, "anthropic-messages");
+
+    const auditLogPath = join(basePath, ".gsd", "audit", "events.jsonl");
+    assert.ok(existsSync(auditLogPath), "audit events file should be created");
+    const auditLines = readFileSync(auditLogPath, "utf-8")
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { category: string; type: string; traceId: string; payload: Record<string, unknown> });
+    const switchEvent = auditLines.find((e) => e.category === "model-policy" && e.type === "provider-switch");
+    assert.ok(switchEvent, "a model-policy/provider-switch audit event should be present");
+    assert.equal(switchEvent?.traceId, "trace-provider-switch-1");
+    assert.equal(switchEvent?.payload.fromApi, "anthropic-messages");
+    assert.equal(switchEvent?.payload.toApi, "openai-responses");
+
+    const stats = getProviderSwitchStats();
+    assert.ok("trace-provider-switch-1" in stats.byTrace, "trace-keyed bucket should be populated");
+    assert.equal(stats.byTrace["trace-provider-switch-1"]?.switches, 1);
+  } finally {
+    cleanup();
+  }
+});
+
+test("empty report does not bump counter or emit a notification", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Same-API transform → no transformations → empty report.
+    const sameApiModel = {
+      id: "claude-sonnet-4-6",
+      name: "Claude Sonnet 4.6",
+      api: "anthropic-messages",
+      provider: "anthropic",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 200000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    transformMessagesWithReport(
+      [
+        {
+          role: "user" as const,
+          content: "plain text — no transforms triggered",
+        },
+      ] as Parameters<typeof transformMessagesWithReport>[0],
+      sameApiModel,
+      undefined,
+      "anthropic-messages",
+    );
+
+    assert.equal(getProviderSwitchStats().totalSwitches, 0);
+    assert.equal(readNotifications(basePath).length, 0);
+  } finally {
+    cleanup();
+  }
+});

package/src/resources/extensions/gsd/tests/resume-dispatch-worktree.test.ts

@@ -10,7 +10,11 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { _resolvePausedResumeBasePathForTest } from "../auto.ts";
+// ADR-016 phase 2 / B3 (#5621): the legacy `resolvePausedResumeBasePath`
+// helper was retired and folded into `WorktreeLifecycle.resumeFromPausedSession`.
+// The pure path-resolution function lives in `worktree-lifecycle.ts` for tests
+// that exercise the path-resolution invariant without constructing a session.
+import { resolvePausedResumeBasePath } from "../worktree-lifecycle.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
@@ -59,7 +63,7 @@ test("resume base path uses paused-session worktreePath when the worktree exists
   try {
     setupWorktreeOnDisk(wt);
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       wt,
     );
   } finally {
@@ -72,7 +76,7 @@ test("resume base path falls back to project root when paused worktree is missin
   const wt = makeWorktreePath(base, "M001-test");
   try {
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       base,
     );
   } finally {

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

@@ -42,16 +42,19 @@ test("State Reconciliation invalidates cache and returns reconciled state", asyn
   assert.equal(result.ok && result.stateSnapshot, state);
 });
 
-test("State Reconciliation blocks when derived state carries blockers", async () => {
+test("State Reconciliation surfaces terminal blockers in result (ADR-017)", async () => {
+  // Under ADR-017, blockers are terminal but do not throw — they ride along
+  // in the result so the orchestrator adapter can map them to ok=false.
   const result = await reconcileBeforeDispatch("/project", {
     invalidateStateCache() {},
     async deriveState() {
       return makeState({ phase: "blocked", blockers: ["slice lock missing"] });
     },
+    registry: [],
   });
 
-  assert.equal(result.ok, false);
-  assert.equal(!result.ok && result.reason, "slice lock missing");
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["slice lock missing"]);
 });
 
 test("Tool Contract compiles known Unit prompt and tool policy", () => {

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

@@ -1,9 +1,11 @@
+// Project/App: GSD-2
+// File Purpose: Verifies GSD session hook widget and footer lifecycle behavior.
+
 /**
- * session-start-footer.test.ts
- *
  * Verifies that register-hooks.ts suppresses the gsd-health widget (not the
- * built-in footer) when isAutoActive() is true, and that setFooter is never
- * called by the extension in either session_start or session_switch.
+ * built-in footer) when isAutoActive() is true, clears stale completion widgets
+ * on inactive session switches, and that setFooter is never called by the
+ * extension in either session_start or session_switch.
  *
  * Testing strategy:
  *   1. Source-code regression guards: structural checks on register-hooks.ts.
@@ -139,6 +141,16 @@ test("session_switch toggles gsd-health from runtime auto state without touching
   widgetCalls.length = 0;
   autoSession.active = false;
   await sessionSwitch!({ reason: "resume" }, ctx);
+  assert.deepEqual(
+    widgetCalls
+      .filter((call) => call.key === "gsd-progress" || call.key === "gsd-outcome")
+      .map((call) => [call.key, call.value]),
+    [
+      ["gsd-progress", undefined],
+      ["gsd-outcome", undefined],
+    ],
+    "session_switch should clear stale GSD completion widgets when auto is inactive",
+  );
   const healthWidgetValues = widgetCalls
     .filter((call) => call.key === "gsd-health")
     .map((call) => call.value);

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -188,6 +188,30 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
+  // newSession() can abort the just-finished provider stream while the last
+  // assistant message still carries the completed unit summary. That is a
+  // session-transition artifact, not a cancellation for the next unit.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{
+        type: "text",
+        text: "Implemented T01 and verified the slice task is complete.",
+      }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
 test("non-abort errors during session-switch are not propagated through this helper", () => {
   // Real provider errors (rate-limit, network, unsupported-model) are handled
   // by the post-switch retry pipeline — not by the in-flight switch handler.

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -10,9 +10,10 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 import {
   openDatabase,
   closeDatabase,
@@ -263,63 +264,69 @@ describe("#2945 Bug 2: workflow-reconcile bypasses task validation for complete_
 
 describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merge", () => {
 
-  test("_mergeWorktreeMode calls teardownAutoWorktree after successful merge", async () => {
-    // Test the WorktreeResolver to verify teardown is called after merge.
-    // We use a mock-based approach since actual worktrees require a git repo.
-    let teardownCalled = false;
-    let teardownMilestoneId = "";
-
-    const mockSession = {
-      basePath: "/mock/worktree/M001",
-      originalBasePath: "/mock/project",
-      isolationDegraded: false,
-      gitService: {} as unknown,
-    } as unknown as AutoSession;
-
-    const { WorktreeStateProjection } = await import("../worktree-state-projection.ts");
-    const mockDeps = {
-      isInAutoWorktree: () => true,
-      shouldUseWorktreeIsolation: () => true,
-      getIsolationMode: () => "worktree" as const,
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
-      syncWorktreeStateBack: () => ({ synced: [] }),
-      teardownAutoWorktree: (basePath: string, mid: string) => {
-        teardownCalled = true;
-        teardownMilestoneId = mid;
-      },
-      createAutoWorktree: () => "",
-      enterAutoWorktree: () => "",
-      getAutoWorktreePath: () => null,
-      autoCommitCurrentBranch: () => {},
-      getCurrentBranch: () => "main",
-      checkoutBranch: () => {},
-      autoWorktreeBranch: () => "gsd/M001",
-      resolveMilestoneFile: () => "/mock/roadmap.md",
-      readFileSync: () => "# Roadmap content",
-      GitServiceImpl: class {} as unknown as new (p: string, c: unknown) => unknown,
-      loadEffectiveGSDPreferences: () => undefined,
-      invalidateAllCaches: () => {},
-      captureIntegrationBranch: () => {},
-      enterBranchModeForMilestone: () => {},
-      worktreeProjection: new WorktreeStateProjection(),
-    };
-
-    // We test the behavior contract: after a successful merge, teardown must be called
-    const { WorktreeLifecycle } = await import("../worktree-lifecycle.ts");
-    const lifecycle = new WorktreeLifecycle(mockSession, mockDeps as never);
-
-    const ctx = { notify: () => {} };
-    lifecycle.exitMilestone("M001", { merge: true }, ctx);
-
-    assert.ok(
-      teardownCalled,
-      "teardownAutoWorktree must be called after successful merge in worktree mode",
-    );
-    assert.strictEqual(
-      teardownMilestoneId,
-      "M001",
-      "teardown must be called with the correct milestone ID",
-    );
+  test("_mergeWorktreeMode tears down worktree directory after successful merge", async () => {
+    // ADR-016 phase 2 / C2 (#5625): the worktree-manager primitives
+    // including `teardownAutoWorktree` are inlined into Lifecycle, so
+    // this test can no longer assert via a deps mock. Rewritten to use
+    // a real git fixture and verify the worktree directory is removed
+    // from disk after the merge.
+    const tmpBase = realpathSync(mkdtempSync(join(tmpdir(), "gsd-2945-bug3-")));
+    try {
+      const git = (args: string[]): void => {
+        execFileSync("git", args, { cwd: tmpBase, stdio: "pipe" });
+      };
+      git(["init", "-b", "main"]);
+      git(["config", "user.email", "test@test.com"]);
+      git(["config", "user.name", "Test"]);
+      writeFileSync(join(tmpBase, "README.md"), "# test\n");
+      writeFileSync(join(tmpBase, ".gitignore"), ".gsd/worktrees/\n");
+      mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+      writeFileSync(
+        join(tmpBase, ".gsd", "preferences.md"),
+        "## Git\n- isolation: worktree\n",
+      );
+      git(["add", "."]);
+      git(["commit", "-m", "init"]);
+      git(["checkout", "-b", "milestone/M001"]);
+      git(["checkout", "main"]);
+      const wt = join(tmpBase, ".gsd", "worktrees", "M001");
+      git(["worktree", "add", wt, "milestone/M001"]);
+      mkdirSync(join(tmpBase, ".gsd", "milestones", "M001"), { recursive: true });
+      writeFileSync(
+        join(tmpBase, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+        "# M001\n- [x] S01: Slice one\n",
+      );
+
+      const { WorktreeStateProjection } = await import("../worktree-state-projection.ts");
+      const session = {
+        basePath: wt,
+        originalBasePath: tmpBase,
+        isolationDegraded: false,
+        gitService: {} as unknown,
+        milestoneStartShas: new Map(),
+      } as unknown as AutoSession;
+
+      const deps = {
+        mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+        worktreeProjection: new WorktreeStateProjection(),
+        gitServiceFactory: () => ({}) as unknown as ReturnType<
+          import("../worktree-lifecycle.js").WorktreeLifecycleDeps["gitServiceFactory"]
+        >,
+      };
+
+      const { WorktreeLifecycle } = await import("../worktree-lifecycle.ts");
+      const lifecycle = new WorktreeLifecycle(session, deps as never);
+
+      const ctx = { notify: () => {} };
+      lifecycle.exitMilestone("M001", { merge: true }, ctx);
+
+      assert.ok(
+        !existsSync(wt),
+        `teardownAutoWorktree must be called after successful merge — worktree directory at ${wt} should be removed`,
+      );
+    } finally {
+      try { rmSync(tmpBase, { recursive: true, force: true }); } catch { /* noop */ }
+    }
   });
 });