gsd-pi 2.73.1-dev.d987996 → 2.74.0-dev.0306a2e

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -6,7 +6,7 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -48,3 +48,139 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(result, undefined, "Should not create routing config for copilot");
   });
 });
+
+describe("flat-rate provider extensibility (any/all/custom)", () => {
+  test("regression: built-in providers still flat-rate with no context", () => {
+    assert.equal(isFlatRateProvider("github-copilot"), true);
+    assert.equal(isFlatRateProvider("copilot"), true);
+    assert.equal(isFlatRateProvider("claude-code"), true);
+  });
+
+  test("regression: non-flat-rate API providers return false with no context", () => {
+    assert.equal(isFlatRateProvider("anthropic"), false);
+    assert.equal(isFlatRateProvider("openai"), false);
+    assert.equal(isFlatRateProvider("google-vertex"), false);
+  });
+
+  test("auto-detection: externalCli auth mode marks provider flat-rate", () => {
+    // Any provider registered with authMode: "externalCli" is a local
+    // CLI wrapper around the user's subscription — every request costs
+    // the same regardless of model, so dynamic routing provides no benefit.
+    assert.equal(
+      isFlatRateProvider("my-private-cli", { authMode: "externalCli" }),
+      true,
+    );
+  });
+
+  test("auto-detection: non-externalCli auth modes do not mark provider flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "apiKey" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "oauth" }),
+      false,
+    );
+    assert.equal(
+      isFlatRateProvider("my-http-proxy", { authMode: "none" }),
+      false,
+    );
+  });
+
+  test("user preference: custom provider listed in userFlatRate is flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("my-ollama-proxy", { userFlatRate: ["my-ollama-proxy"] }),
+      true,
+    );
+  });
+
+  test("user preference: case-insensitive match against userFlatRate list", () => {
+    assert.equal(
+      isFlatRateProvider("My-Proxy", { userFlatRate: ["my-proxy"] }),
+      true,
+    );
+    assert.equal(
+      isFlatRateProvider("my-proxy", { userFlatRate: ["MY-PROXY"] }),
+      true,
+    );
+  });
+
+  test("user preference: provider not in userFlatRate list is not flat-rate", () => {
+    assert.equal(
+      isFlatRateProvider("other-proxy", { userFlatRate: ["my-proxy"] }),
+      false,
+    );
+  });
+
+  test("combined signals: built-in list wins even when context is empty", () => {
+    assert.equal(
+      isFlatRateProvider("claude-code", { authMode: "apiKey", userFlatRate: [] }),
+      true,
+    );
+  });
+
+  test("combined signals: externalCli auto-detection wins alongside userFlatRate miss", () => {
+    assert.equal(
+      isFlatRateProvider("my-cli", {
+        authMode: "externalCli",
+        userFlatRate: ["a-different-cli"],
+      }),
+      true,
+    );
+  });
+});
+
+describe("buildFlatRateContext()", () => {
+  test("builds a context from ctx.modelRegistry.getProviderAuthMode + prefs", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: (p: string) =>
+          p === "my-cli" ? "externalCli" : "apiKey",
+      },
+    };
+    const prefs = { flat_rate_providers: ["my-proxy"] };
+
+    const ctxForCli = buildFlatRateContext("my-cli", ctx, prefs);
+    assert.equal(ctxForCli.authMode, "externalCli");
+    assert.deepEqual(ctxForCli.userFlatRate, ["my-proxy"]);
+    assert.equal(isFlatRateProvider("my-cli", ctxForCli), true);
+
+    const ctxForProxy = buildFlatRateContext("my-proxy", ctx, prefs);
+    assert.equal(ctxForProxy.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("my-proxy", ctxForProxy), true);
+
+    const ctxForOther = buildFlatRateContext("anthropic", ctx, prefs);
+    assert.equal(ctxForOther.authMode, "apiKey");
+    assert.equal(isFlatRateProvider("anthropic", ctxForOther), false);
+  });
+
+  test("survives missing ctx and missing prefs", () => {
+    const empty = buildFlatRateContext("anything");
+    assert.equal(empty.authMode, undefined);
+    assert.equal(empty.userFlatRate, undefined);
+    assert.equal(isFlatRateProvider("anything", empty), false);
+  });
+
+  test("survives a registry lookup that throws", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => {
+          throw new Error("registry boom");
+        },
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    // Error must be swallowed — authMode left undefined, function returns.
+    assert.equal(result.authMode, undefined);
+  });
+
+  test("registry returning a non-canonical auth mode is ignored", () => {
+    const ctx = {
+      modelRegistry: {
+        getProviderAuthMode: () => "weird-mode",
+      },
+    };
+    const result = buildFlatRateContext("anything", ctx);
+    assert.equal(result.authMode, undefined);
+  });
+});

package/src/resources/extensions/gsd/tests/graph-context.test.ts

@@ -0,0 +1,337 @@
+/**
+ * graph-context.test.ts — Unit tests for inlineGraphSubgraph().
+ *
+ * Covers:
+ *   Group 1: Null-return paths (empty term, zero nodes, missing graph.json)
+ *   Group 2: Correct output formatting (nodes, edges, stale annotation)
+ *   Group 3: Node formatting (description, confidence, no-description)
+ *
+ * Testing strategy:
+ *   @gsd-build/mcp-server is dynamically imported inside inlineGraphSubgraph().
+ *   Because node:test (v22) does not support mock.module() without the
+ *   --experimental-test-module-mocks flag (not enabled in test:unit), we
+ *   exercise the real graphQuery/graphStatus functions by controlling the
+ *   on-disk graph.json that those functions read. This is a clean, deterministic
+ *   approach that avoids all module-level mocking.
+ *
+ *   Fixture layout per test:
+ *     <tmpDir>/.gsd/graphs/graph.json
+ *
+ *   builtAt controls staleness: old timestamp → stale, recent → fresh.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { inlineGraphSubgraph } from "../graph-context.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+interface TestNode {
+  id: string;
+  label: string;
+  type: string;
+  confidence: string;
+  description?: string;
+  sourceFile?: string;
+}
+
+interface TestEdge {
+  from: string;
+  to: string;
+  type: string;
+  confidence: string;
+}
+
+interface GraphFixture {
+  nodes: TestNode[];
+  edges: TestEdge[];
+  /** ISO timestamp for graph.builtAt. Controls staleness. Default: recent (not stale). */
+  builtAt?: string;
+}
+
+/** Returns an ISO timestamp that is stale (> 24h ago). */
+function staleTimestamp(hoursAgo = 26): string {
+  return new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
+}
+
+/** Returns an ISO timestamp that is fresh (< 24h ago). */
+function freshTimestamp(): string {
+  return new Date(Date.now() - 30 * 60 * 1000).toISOString(); // 30 minutes ago
+}
+
+/**
+ * Creates a temp project directory with a .gsd/graphs/graph.json file.
+ * Returns the projectDir path. Caller is responsible for cleanup.
+ */
+function makeProjectDir(fixture: GraphFixture): string {
+  const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-test-"));
+  const gsdDir = join(projectDir, ".gsd");
+  const graphsDir = join(gsdDir, "graphs");
+  mkdirSync(graphsDir, { recursive: true });
+
+  const graph = {
+    nodes: fixture.nodes,
+    edges: fixture.edges,
+    builtAt: fixture.builtAt ?? freshTimestamp(),
+  };
+
+  writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+  return projectDir;
+}
+
+/** Removes a temp directory, suppressing errors on Windows. */
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/** Minimal node factory. */
+function makeNode(overrides: Partial<TestNode> & { id: string; label: string }): TestNode {
+  return {
+    type: "CLASS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+/** Minimal edge factory. */
+function makeEdge(overrides: Partial<TestEdge> & { from: string; to: string }): TestEdge {
+  return {
+    type: "CALLS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+// ─── Group 1: Null returns ────────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — null returns", () => {
+  it("returns null immediately for empty string term", async () => {
+    // No graph.json needed — exits before any file I/O
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null for whitespace-only term", async () => {
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "   ", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null when graphQuery returns zero nodes (no matching term in graph)", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+    });
+    try {
+      // "zzznomatch999" is intentionally absent from the fixture
+      const result = await inlineGraphSubgraph(projectDir, "zzznomatch999", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns null (no throw) when graph.json is missing", async () => {
+    // A project dir with no .gsd directory at all — graphQuery returns zero nodes
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-nofile-"));
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "auth", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 2: Correct output formatting ──────────────────────────────────────
+
+describe("inlineGraphSubgraph — correct output", () => {
+  it("returns block with section header and node labels when term matches", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "UserService" }),
+        makeNode({ id: "n2", label: "UserRepository" }),
+      ],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "User", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("### Knowledge Graph Context"), "should include section header");
+      assert.ok(result!.includes("UserService"), "should include first node label");
+      assert.ok(result!.includes("UserRepository"), "should include second node label");
+      assert.ok(result!.includes("Nodes (2)"), "should show node count");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include Relations section when edges array is empty", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthController" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("Relations"), "should not include Relations section for zero edges");
+      assert.ok(!result!.includes("⚠"), "should not include stale warning for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes Relations section when edges are present", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "AuthService" }),
+        makeNode({ id: "n2", label: "UserRepo" }),
+      ],
+      edges: [makeEdge({ from: "n1", to: "n2", type: "CALLS" })],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("Relations (1)"), "should show edge count");
+      assert.ok(result!.includes("→[CALLS]→"), "should include edge type in arrow notation");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes stale annotation when graph was built more than 24h ago", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: staleTimestamp(26), // 26 hours ago → stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("⚠ Graph last built"), "should include stale annotation");
+      assert.ok(result!.includes("h ago"), "should include hours-ago text");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include stale annotation for a fresh graph", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: freshTimestamp(), // 30 minutes ago → not stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("⚠"), "should not include stale annotation for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns valid block even when graph.json has corrupted builtAt (graphStatus throws internally)", async () => {
+    // Write a graph.json with an invalid builtAt — graphStatus will catch and return {exists: false}
+    // inlineGraphSubgraph should still return the node block without stale annotation
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-corrupt-"));
+    const gsdDir = join(projectDir, ".gsd");
+    const graphsDir = join(gsdDir, "graphs");
+    mkdirSync(graphsDir, { recursive: true });
+
+    const graph = {
+      nodes: [{ id: "n1", label: "AuthController", type: "CLASS", confidence: "INFERRED" }],
+      edges: [],
+      builtAt: "NOT-A-DATE", // invalid ISO — will cause Date.now() - NaN to produce NaN
+    };
+    writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      // graphQuery reads the file and finds the node; graphStatus may return {exists: true, stale: false/true}
+      // Either way, function must not throw and must return a string with node content
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("AuthController"), "should include node label");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("passes the budget option to graphQuery (enforces node count limit)", async () => {
+    // Each node uses ~20 tokens. With budget=20, only ~1 node should be returned.
+    // Build a graph with many nodes all matching the same term.
+    const nodes: TestNode[] = Array.from({ length: 10 }, (_, i) =>
+      makeNode({ id: `n${i}`, label: `AuthModule${i}` })
+    );
+    const projectDir = makeProjectDir({ nodes, edges: [] });
+    try {
+      const resultSmall = await inlineGraphSubgraph(projectDir, "Auth", { budget: 20 });
+      const resultLarge = await inlineGraphSubgraph(projectDir, "Auth", { budget: 10000 });
+
+      // Both should return something (at least 1 node matches)
+      assert.ok(resultSmall !== null, "small-budget result should not be null");
+      assert.ok(resultLarge !== null, "large-budget result should not be null");
+
+      // With a very small budget (20 tokens ≈ 1 node), fewer nodes should appear
+      const smallNodeCount = (resultSmall!.match(/- \*\*/g) || []).length;
+      const largeNodeCount = (resultLarge!.match(/- \*\*/g) || []).length;
+      assert.ok(
+        smallNodeCount <= largeNodeCount,
+        `small-budget should return <= nodes than large-budget (got ${smallNodeCount} vs ${largeNodeCount})`,
+      );
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 3: Node formatting ─────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — node formatting", () => {
+  it("includes description after em-dash when node has description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "JwtValidator", description: "JWT validation" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Jwt", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("— JWT validation"), "should include description after em-dash");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("omits em-dash suffix when node has no description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "TokenStore" })], // no description
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Token", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      const lines = result!.split("\n");
+      const nodeLine = lines.find((l) => l.includes("TokenStore"));
+      assert.ok(nodeLine !== undefined, "node line should be present");
+      assert.ok(!nodeLine.includes("—"), "node line should not include em-dash when no description");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes confidence tier in the node output line", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService", confidence: "EXTRACTED" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("EXTRACTED"), "should include the confidence tier in node line");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -80,7 +80,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 14, 'schema version should be 14');
+    assert.deepStrictEqual(version?.['version'], 15, 'schema version should be 15');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -198,7 +198,7 @@ test("session_start bootstraps the health widget alongside notifications", async
     },
   } as any;
 
-  registerHooks(pi);
+  registerHooks(pi, []);
   const sessionStart = handlers.get("session_start");
   assert.ok(sessionStart, "session_start handler is registered");
 

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -691,7 +691,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → blocked phase", async () => {
+  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,7 +736,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    assert.equal(state.phase, "blocked", "circular deps should produce blocked phase");
+    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
+    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
+    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
   });
 });
 

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -92,6 +92,7 @@ function makeMockDeps(
     getPriorSliceCompletionBlocker: () => null,
     getMainBranch: () => "main",
     closeoutUnit: async () => {},
+    autoCommitUnit: async () => null,
     recordOutcome: () => {},
     writeLock: () => {},
     captureAvailableSkills: () => {},
@@ -567,7 +568,15 @@ test("unit-end event contains errorContext when unit is cancelled with structure
   const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
   _resetPendingResolve();
 
-  const deps = makeMockDeps(capture);
+  let pauseCalls = 0;
+  let commitCalls = 0;
+  const deps = makeMockDeps(capture, {
+    pauseAuto: async () => { pauseCalls++; },
+    autoCommitUnit: async () => {
+      commitCalls++;
+      return "commit";
+    },
+  });
   const ic = makeIC(deps);
   const iterData: IterationData = {
     unitType: "execute-task",
@@ -593,10 +602,68 @@ test("unit-end event contains errorContext when unit is cancelled with structure
   // Transient timeout cancellations pause (recoverable) instead of hard-stopping
   assert.equal(result.action, "break");
   assert.equal((result as any).reason, "session-timeout");
+  assert.equal(pauseCalls, 1, "timeout cancellations should pause auto-mode exactly once");
+  assert.equal(commitCalls, 1, "timeout cancellations should flush a unit auto-commit once");
 
   // Verify error classification used structured errorContext on the window entry
   const entry = loopState.recentUnits[loopState.recentUnits.length - 1];
   assert.ok(entry.error, "window entry must have error set");
   assert.ok(entry.error!.startsWith("timeout:"), "error must start with category from errorContext");
   assert.ok(entry.error!.includes("Hard timeout error"), "error must include the errorContext message");
+
+  const endEvents = capture.events.filter(e => e.eventType === "unit-end");
+  assert.equal(endEvents.length, 1, "timeout cancellations should still emit unit-end");
+  assert.equal((endEvents[0].data as any).status, "cancelled");
+  assert.equal((endEvents[0].data as any).artifactVerified, false);
+  assert.equal((endEvents[0].data as any).errorContext.category, "timeout");
+});
+
+test("session-failed cancellations close out and emit unit-end before hard stop", async () => {
+  const capture = createEventCapture();
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  _resetPendingResolve();
+
+  let closeoutCalls = 0;
+  let commitCalls = 0;
+  let stopCalls = 0;
+  const deps = makeMockDeps(capture, {
+    closeoutUnit: async () => { closeoutCalls++; },
+    autoCommitUnit: async () => {
+      commitCalls++;
+      return "commit";
+    },
+    stopAuto: async () => { stopCalls++; },
+  });
+  const ic = makeIC(deps);
+  const iterData: IterationData = {
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    prompt: "do stuff",
+    finalPrompt: "do stuff",
+    pauseAfterUatDispatch: false,
+    state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
+    mid: "M001",
+    midTitle: "Test",
+    isRetry: false,
+    previousTier: undefined,
+  };
+  const loopState: LoopState = { recentUnits: [{ key: "execute-task/M001/S01/T01" }], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
+
+  const unitPromise = runUnitPhase(ic, iterData, loopState);
+  await new Promise(r => setTimeout(r, 50));
+
+  resolveAgentEndCancelled({ message: "session bootstrap exploded", category: "session-failed", isTransient: false });
+
+  const result = await unitPromise;
+  assert.equal(result.action, "break");
+  assert.equal((result as any).reason, "session-failed");
+  assert.equal(closeoutCalls, 1, "session-failed cancellations should close out the unit before stopping");
+  assert.equal(commitCalls, 1, "session-failed cancellations should try one auto-commit flush");
+  assert.equal(stopCalls, 1, "session-failed cancellations should hard-stop auto-mode");
+
+  const endEvents = capture.events.filter(e => e.eventType === "unit-end");
+  assert.equal(endEvents.length, 1, "session-failed cancellations should emit unit-end");
+  assert.equal((endEvents[0].data as any).status, "cancelled");
+  assert.equal((endEvents[0].data as any).artifactVerified, false);
+  assert.equal((endEvents[0].data as any).errorContext.category, "session-failed");
 });

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 14, 'new DB should be at schema version 14');
+  assert.deepStrictEqual(version?.v, 15, 'new DB should be at schema version 15');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();
@@ -413,4 +413,3 @@ test('md-importer: round-trip fidelity', () => {
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,10 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 14 (after indexes + slice_dependencies)
+  // Verify schema version is 15 (UOK gate/git/audit projection tables included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 14, 'schema version should be 14');
+  assert.deepStrictEqual(version?.['v'], 15, 'schema version should be 15');
 
   closeDatabase();
 });
-