gsd-pi 2.58.0-dev.d63175c → 2.58.0-dev.e002a57

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

@@ -0,0 +1,127 @@
+/**
+ * discuss-empty-db-fallback.test.ts — Tests for #2892.
+ *
+ * When the DB is open but empty (e.g., after crash/truncation),
+ * getMilestoneSlices() returns [] and showDiscuss() incorrectly declares
+ * "All slices are complete." The fix adds a roadmap fallback: when the DB
+ * returns zero slices but a ROADMAP file exists, parse slices from the
+ * roadmap instead of treating zero slices as "all complete."
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function readGuidedFlowSource(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
+}
+
+const SAMPLE_ROADMAP = `# M012 Roadmap
+
+## Slices
+- [ ] **S01: Core setup** \`risk:low\` \`depends:[]\`
+  > After this: basic project scaffolding works
+- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
+  > After this: users can log in
+- [ ] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
+  > After this: dashboard renders
+`;
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("discuss-empty-db-fallback (#2892)", () => {
+
+  test("1. parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
+    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+    assert.strictEqual(slices.length, 3, "should parse 3 slices from sample roadmap");
+    assert.strictEqual(slices[0]!.id, "S01");
+    assert.strictEqual(slices[1]!.id, "S02");
+    assert.strictEqual(slices[2]!.id, "S03");
+    // All slices are incomplete ([ ] not [x])
+    assert.ok(slices.every(s => !s.done), "all slices should be incomplete");
+  });
+
+  test("2. guided-flow imports parseRoadmapSlices for roadmap fallback", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("parseRoadmapSlices"),
+      "guided-flow must import parseRoadmapSlices to support roadmap fallback when DB is empty",
+    );
+  });
+
+  test("3. guided-flow has roadmap fallback when normSlices is empty but roadmapContent exists", () => {
+    const source = readGuidedFlowSource();
+    // The fix must add a fallback that checks normSlices.length === 0 && roadmapContent
+    // and repopulates normSlices from the roadmap before the pendingSlices guard.
+    //
+    // Pattern: after DB query produces normSlices, if empty + roadmap exists,
+    // fall back to parseRoadmapSlices(roadmapContent).
+    const fallbackPattern = /normSlices\.length\s*===\s*0\s*&&\s*roadmapContent/;
+    assert.ok(
+      fallbackPattern.test(source),
+      "guided-flow must check normSlices.length === 0 && roadmapContent to trigger roadmap fallback",
+    );
+  });
+
+  test("4. guided-flow no longer has unguarded pendingSlices === 0 exit after DB-only query", () => {
+    const source = readGuidedFlowSource();
+    // Extract the showDiscuss function body
+    const fnMatch = source.match(
+      /async function showDiscuss\s*\([^)]*\)[^{]*\{([\s\S]*?)\nfunction\s/,
+    );
+    assert.ok(!!fnMatch, "showDiscuss function body must be found");
+
+    if (fnMatch) {
+      const body = fnMatch[1]!;
+      // After the DB query block (isDbAvailable/getMilestoneSlices), there should
+      // be a roadmap fallback BEFORE the pendingSlices.length === 0 check.
+      // Find the getMilestoneSlices call and the pendingSlices === 0 check
+      const dbQueryIdx = body.indexOf("getMilestoneSlices");
+      const fallbackIdx = body.indexOf("parseRoadmapSlices");
+      const pendingGuardIdx = body.indexOf('pendingSlices.length === 0');
+
+      assert.ok(dbQueryIdx > 0, "getMilestoneSlices call must exist");
+      assert.ok(fallbackIdx > 0, "parseRoadmapSlices fallback must exist");
+      assert.ok(pendingGuardIdx > 0, "pendingSlices.length === 0 guard must exist");
+      assert.ok(
+        fallbackIdx > dbQueryIdx && fallbackIdx < pendingGuardIdx,
+        "parseRoadmapSlices fallback must appear BETWEEN DB query and pendingSlices === 0 guard",
+      );
+    }
+  });
+
+  test("5. roadmap-parsed slices map to NormSlice format with done=false by default", () => {
+    // When falling back to roadmap, incomplete slices ([ ]) should map to done:false,
+    // ensuring they appear as pending and are NOT falsely reported as complete.
+    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 3,
+      "all 3 incomplete roadmap slices should be pending — not falsely treated as complete");
+  });
+
+  test("6. roadmap with completed slices correctly reports them as done", () => {
+    const completedRoadmap = `# M012 Roadmap
+
+## Slices
+- [x] **S01: Core setup** \`risk:low\` \`depends:[]\`
+  > After this: basic project scaffolding works
+- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
+  > After this: users can log in
+- [x] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
+  > After this: dashboard renders
+`;
+    const slices = parseRoadmapSlices(completedRoadmap);
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 1, "only S02 should be pending");
+    assert.strictEqual(pendingSlices[0]!.id, "S02");
+  });
+});

package/src/resources/extensions/gsd/tests/discuss-queued-milestones.test.ts

@@ -238,4 +238,44 @@ describe("discuss-queued-milestones (#2307)", () => {
       "queued milestone picker must label entries with [queued] to distinguish from active",
     );
   });
+
+  // ─── #3150: allDiscussed early-return must not block queued milestone discussion ──
+
+  test("12. allDiscussed path checks for pending milestones before returning (#3150)", () => {
+    const source = readGuidedFlowSource();
+
+    // Extract the allDiscussed block — the if (allDiscussed) { ... } body
+    const allDiscussedMatch = source.match(
+      /const allDiscussed = pendingSlices\.every\([\s\S]*?\n    if \(allDiscussed\) \{([\s\S]*?)\n    \}/,
+    );
+    assert.ok(!!allDiscussedMatch, "allDiscussed guard block must exist in showDiscuss()");
+
+    if (allDiscussedMatch) {
+      const body = allDiscussedMatch[1];
+      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
+      assert.ok(
+        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
+        "allDiscussed block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
+      );
+    }
+  });
+
+  test("13. pendingSlices.length===0 path checks for pending milestones before returning (#3150)", () => {
+    const source = readGuidedFlowSource();
+
+    // Find the pendingSlices.length === 0 guard block
+    const zeroSlicesMatch = source.match(
+      /if \(pendingSlices\.length === 0\) \{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(!!zeroSlicesMatch, "pendingSlices.length === 0 guard block must exist in showDiscuss()");
+
+    if (zeroSlicesMatch) {
+      const body = zeroSlicesMatch[1];
+      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
+      assert.ok(
+        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
+        "pendingSlices.length===0 block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
+      );
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -87,7 +87,26 @@ export function load(url, context, nextLoad) {
         emitDecoratorMetadata: true,
       },
     });
-    return { format: 'module', source: outputText, shortCircuit: true };
+    // Inject CJS-compatible globals (__dirname, __filename, require) so that
+    // workspace packages compiled as ESM can still use them.  This avoids the
+    // need for import.meta.url behind indirect invocation patterns that fail in
+    // CJS and in dynamically-created scopes.
+    // Only inject globals that the source file doesn't already declare itself.
+    const preambleLines = [
+      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
+      'import { dirname as __preamble_dn } from "node:path";',
+      'import { createRequire as __preamble_cR } from "node:module";',
+    ];
+    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
+      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
+    }
+    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
+      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
+    }
+    if (!outputText.includes('const require') && !outputText.includes('let require')) {
+      preambleLines.push('const require = __preamble_cR(import.meta.url);');
+    }
+    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
   }
   return nextLoad(url, context);
 }

package/src/resources/extensions/gsd/tests/doctor-providers.test.ts

@@ -484,3 +484,120 @@ test("runProviderChecks uses object provider field for anthropic-vertex models",
   rmSync(repo, { recursive: true, force: true });
   rmSync(tmpHome, { recursive: true, force: true });
 });
+
+// ─── Cross-provider routing: Codex & Gemini CLI (#2922) ────────────────────
+
+test("runProviderChecks reports ok for Google via google-gemini-cli auth.json (#2922)", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-gemini-cli-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gemini-2.5-pro",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-gemini-cli-home-")));
+  const agentDir = join(tmpHome, ".gsd", "agent");
+  mkdirSync(agentDir, { recursive: true });
+
+  // google-gemini-cli OAuth in auth.json (no google API key)
+  const authData = {
+    "google-gemini-cli": { type: "oauth", apiKey: "ya29.gemini-cli-token", expires: Date.now() + 3_600_000 },
+  };
+  writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+  withEnv({
+    HOME: tmpHome,
+    GEMINI_API_KEY: undefined,
+    GOOGLE_API_KEY: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const google = results.find(r => r.name === "google");
+      assert.ok(google, "google result should exist");
+      assert.equal(google!.status, "ok", "should be ok when google-gemini-cli auth is available (#2922)");
+      assert.ok(google!.message.includes("Google Gemini CLI"), "should mention Gemini CLI as the source (#2922)");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("runProviderChecks reports ok for OpenAI via openai-codex auth.json (#2922)", () => {
+  const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-codex-repo-")));
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "models:",
+      "  execution: gpt-4o",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const tmpHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-providers-codex-home-")));
+  const agentDir = join(tmpHome, ".gsd", "agent");
+  mkdirSync(agentDir, { recursive: true });
+
+  // openai-codex OAuth in auth.json (no openai API key)
+  const authData = {
+    "openai-codex": { type: "oauth", apiKey: "codex-token", expires: Date.now() + 3_600_000 },
+  };
+  writeFileSync(join(agentDir, "auth.json"), JSON.stringify(authData));
+
+  withEnv({
+    HOME: tmpHome,
+    OPENAI_API_KEY: undefined,
+    // Clear Copilot env vars so it doesn't route through Copilot
+    COPILOT_GITHUB_TOKEN: undefined,
+    GH_TOKEN: undefined,
+    GITHUB_TOKEN: undefined,
+  }, () => {
+    withCwd(repo, () => {
+      const results = runProviderChecks();
+      const openai = results.find(r => r.name === "openai");
+      assert.ok(openai, "openai result should exist");
+      assert.equal(openai!.status, "ok", "should be ok when openai-codex auth is available (#2922)");
+      assert.ok(openai!.message.includes("Codex"), "should mention Codex as the source (#2922)");
+    });
+  });
+
+  rmSync(repo, { recursive: true, force: true });
+  rmSync(tmpHome, { recursive: true, force: true });
+});
+
+test("PROVIDER_ROUTES includes google-gemini-cli as route for google (#2922)", async () => {
+  const { readFileSync: readFS } = await import("node:fs");
+  const { dirname: dirn, join: joinPath } = await import("node:path");
+  const { fileURLToPath: fileUrl } = await import("node:url");
+  const __dir = dirn(fileUrl(import.meta.url));
+  const src = readFS(joinPath(__dir, "..", "doctor-providers.ts"), "utf-8");
+
+  // PROVIDER_ROUTES must map google -> [..., "google-gemini-cli"]
+  assert.ok(
+    src.includes('"google-gemini-cli"'),
+    'PROVIDER_ROUTES must include "google-gemini-cli" as a route (#2922)',
+  );
+});
+
+test("PROVIDER_ROUTES includes openai-codex as route for openai (#2922)", async () => {
+  const { readFileSync: readFS } = await import("node:fs");
+  const { dirname: dirn, join: joinPath } = await import("node:path");
+  const { fileURLToPath: fileUrl } = await import("node:url");
+  const __dir = dirn(fileUrl(import.meta.url));
+  const src = readFS(joinPath(__dir, "..", "doctor-providers.ts"), "utf-8");
+
+  // PROVIDER_ROUTES must map openai -> [..., "openai-codex"]
+  assert.ok(
+    src.includes('"openai-codex"'),
+    'PROVIDER_ROUTES must include "openai-codex" as a route (#2922)',
+  );
+});

package/src/resources/extensions/gsd/tests/dynamic-routing-default.test.ts

@@ -0,0 +1,20 @@
+/**
+ * Dynamic routing default — verifies routing is enabled by default.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { defaultRoutingConfig } from "../model-router.js";
+
+test("defaultRoutingConfig returns enabled: true", () => {
+  const config = defaultRoutingConfig();
+  assert.equal(config.enabled, true, "dynamic routing should be enabled by default");
+});
+
+test("defaultRoutingConfig enables all routing features", () => {
+  const config = defaultRoutingConfig();
+  assert.equal(config.escalate_on_failure, true);
+  assert.equal(config.budget_pressure, true);
+  assert.equal(config.cross_provider, true);
+  assert.equal(config.hooks, true);
+});

package/src/resources/extensions/gsd/tests/empty-content-abort-loop.test.ts

@@ -0,0 +1,74 @@
+/**
+ * empty-content-abort-loop.test.ts — Regression test for #2695.
+ *
+ * When the LLM sends an assistant message with empty `content: []` and
+ * `stopReason: "aborted"`, this is NOT a fatal abort — it is a non-fatal
+ * end-of-turn. The abort handler in agent-end-recovery.ts must distinguish
+ * this case and NOT pause auto-mode, allowing the loop to continue via
+ * resolveAgentEnd instead of entering a stuck re-dispatch loop.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
+
+function getRecoverySource(): string {
+  return readFileSync(RECOVERY_PATH, "utf-8");
+}
+
+test("agent-end-recovery.ts does not pause on aborted messages with empty content (#2695)", () => {
+  const source = getRecoverySource();
+
+  // The abort handler at `stopReason === "aborted"` must check for empty content
+  // before deciding to pause. An empty content array is a non-fatal agent stop.
+  const abortIdx = source.indexOf('stopReason === "aborted"');
+  assert.ok(abortIdx > -1, "abort handler must exist in agent-end-recovery.ts");
+
+  // Extract the region around the abort handler (enough to see the guard logic)
+  const abortRegion = source.slice(Math.max(0, abortIdx - 200), abortIdx + 600);
+
+  // Must check for empty content before pausing
+  assert.ok(
+    abortRegion.includes("content") && (abortRegion.includes("length") || abortRegion.includes("?.length")),
+    "abort handler must inspect content array length to distinguish empty-content aborts from fatal aborts (#2695)",
+  );
+});
+
+test("agent-end-recovery.ts routes empty-content aborted messages to resolveAgentEnd (#2695)", () => {
+  const source = getRecoverySource();
+
+  // The abort block must have a path that calls resolveAgentEnd for empty-content messages
+  // instead of unconditionally calling pauseAuto
+  const abortIdx = source.indexOf('stopReason === "aborted"');
+  assert.ok(abortIdx > -1, "abort handler must exist");
+
+  // Get the full abort handling block (from the if to the next stopReason check or success path)
+  const afterAbort = source.slice(abortIdx, abortIdx + 800);
+
+  // The abort block must have a code path that calls resolveAgentEnd (for empty-content case)
+  assert.ok(
+    afterAbort.includes("resolveAgentEnd"),
+    "abort handler must route empty-content aborted messages to resolveAgentEnd instead of always pausing (#2695)",
+  );
+});
+
+test("agent-end-recovery.ts checks for errorMessage presence in abort handler (#2695)", () => {
+  const source = getRecoverySource();
+
+  const abortIdx = source.indexOf('stopReason === "aborted"');
+  assert.ok(abortIdx > -1, "abort handler must exist");
+
+  const abortRegion = source.slice(abortIdx, abortIdx + 600);
+
+  // Fatal aborts should have error context (errorMessage field).
+  // The handler should check for this to distinguish fatal from non-fatal aborts.
+  assert.ok(
+    abortRegion.includes("errorMessage"),
+    "abort handler must check for errorMessage to distinguish fatal aborts from empty-content non-fatal stops (#2695)",
+  );
+});

package/src/resources/extensions/gsd/tests/event-replay-idempotency.test.ts

@@ -0,0 +1,140 @@
+// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+  updateTaskStatus,
+  insertVerificationEvidence,
+  upsertDecision,
+} from "../gsd-db.ts";
+import { extractEntityKey } from "../workflow-reconcile.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+const MID = "M001";
+const SID = "S01";
+const TID = "T01";
+const TS = new Date().toISOString();
+
+function setupDb(): void {
+  openDatabase(":memory:");
+  insertMilestone({ id: MID, title: "Test Milestone" });
+  insertSlice({ id: SID, milestoneId: MID, title: "Test Slice" });
+  insertTask({ id: TID, sliceId: SID, milestoneId: MID, title: "Test Task" });
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("event-replay-idempotency", () => {
+  beforeEach(() => {
+    setupDb();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+  });
+
+  test("updateTaskStatus is idempotent for complete_task replay", () => {
+    // Simulates replaying a complete_task event twice (e.g. crash recovery)
+    updateTaskStatus(MID, SID, TID, "done", TS);
+    updateTaskStatus(MID, SID, TID, "done", TS);
+
+    const task = getTask(MID, SID, TID);
+    assert.ok(task !== null, "task should exist after status update");
+    assert.equal(task!.status, "done", "status should be 'done' after double replay");
+  });
+
+  test("updateTaskStatus is idempotent for start_task replay", () => {
+    // Simulates replaying a start_task event twice
+    updateTaskStatus(MID, SID, TID, "in-progress");
+    updateTaskStatus(MID, SID, TID, "in-progress");
+
+    const task = getTask(MID, SID, TID);
+    assert.ok(task !== null, "task should exist after status update");
+    assert.equal(task!.status, "in-progress", "status should be 'in-progress' after double replay");
+  });
+
+  test("updateTaskStatus for report_blocker does not set blocker_discovered flag (M4)", () => {
+    // M4 finding: report_blocker replay only calls updateTaskStatus("blocked").
+    // The blocker_discovered column is NOT set during replay — this is a known
+    // lossy replay: status is recovered but the blocker flag is not.
+    updateTaskStatus(MID, SID, TID, "blocked");
+
+    const task = getTask(MID, SID, TID);
+    assert.ok(task !== null, "task should exist after blocked status update");
+    assert.equal(task!.status, "blocked", "status should be 'blocked'");
+    assert.equal(
+      task!.blocker_discovered,
+      false,
+      "blocker_discovered should remain false — report_blocker replay is lossy (M4 finding)",
+    );
+  });
+
+  test("insertVerificationEvidence is NOT idempotent — duplicates accumulate (M5)", () => {
+    // M5 finding: insertVerificationEvidence uses a plain INSERT (no ON CONFLICT),
+    // so replaying the same record_verification event twice produces two rows.
+    // Both calls must succeed without throwing — the duplication is the risk.
+    const evidence = {
+      taskId: TID,
+      sliceId: SID,
+      milestoneId: MID,
+      command: "npm test",
+      exitCode: 0,
+      verdict: "pass",
+      durationMs: 1200,
+    };
+
+    assert.doesNotThrow(
+      () => insertVerificationEvidence(evidence),
+      "first insertVerificationEvidence call should not throw",
+    );
+    assert.doesNotThrow(
+      () => insertVerificationEvidence(evidence),
+      "second insertVerificationEvidence call should not throw — duplicates accumulate silently (M5 finding)",
+    );
+  });
+
+  test("upsertDecision is idempotent via INSERT OR REPLACE", () => {
+    // save_decision replay uses upsertDecision which is INSERT OR REPLACE,
+    // so replaying the same decision id twice overwrites without error.
+    const base = {
+      id: "arch:logging",
+      when_context: "during planning",
+      scope: "arch",
+      decision: "logging",
+      rationale: "structured logs",
+      revisable: "yes" as const,
+      made_by: "agent" as const,
+      superseded_by: null,
+    };
+
+    upsertDecision({ ...base, choice: "structured" });
+    upsertDecision({ ...base, choice: "unstructured" });
+
+    // No error means the second call replaced the first — idempotent at the id level.
+    // The final choice is "unstructured" per INSERT OR REPLACE semantics.
+  });
+
+  test("unknown event commands in replayEvents are silently skipped — extractEntityKey returns null for unknown commands", () => {
+    // replayEvents uses a switch/default that silently skips unrecognised commands.
+    // We verify this via extractEntityKey which follows the same command set.
+    // A future_command not in the switch must return null (not throw).
+    const event = {
+      cmd: "future_command",
+      params: { foo: "bar" },
+      ts: new Date().toISOString(),
+      hash: "0000000000000000",
+      actor: "agent" as const,
+      session_id: "test-session",
+    };
+
+    const key = extractEntityKey(event);
+    assert.equal(key, null, "extractEntityKey should return null for unknown commands");
+  });
+});