gsd-pi 2.81.0-dev.72a81bdf3 → 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/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/workflow-logger.ts

@@ -65,6 +65,10 @@ export type LogComponent =
   | "memory-embeddings" // Memory layer embedding generation
   | "memory-ingest"     // Memory layer ingestion pipeline
   | "memory-backfill"   // ADR-013: decisions->memories backfill
+  | "memory-consolidation" // ADR-013: legacy memory surface gap scanner
+  | "knowledge-backfill" // ADR-013: KNOWLEDGE.md->memories backfill
+  | "knowledge-projection" // ADR-013: KNOWLEDGE.md projection renderer
+  | "knowledge-capture" // ADR-013: KNOWLEDGE.md capture pipeline
   | "memory-store"      // Memory CRUD layer — surfaces SQLite/store-level faults (#4967)
   | "context-mode"     // Context-mode exec sandbox and compaction snapshot
   | "preflight"        // Clean-root preflight gate at milestone completion