@vellumai/assistant 0.7.3 → 0.8.0

package/src/__tests__/injector-chain.test.ts

@@ -24,22 +24,30 @@
  *    content.
  */
 
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-import {
-  applyRuntimeInjections,
-  composeInjectorChain,
-} from "../daemon/conversation-runtime-assembly.js";
-import {
-  DEFAULT_INJECTOR_ORDER,
-  defaultInjectorsPlugin,
-} from "../plugins/defaults/injectors.js";
-
-// This test exercises v1 PKB injection. The `memory-v2-enabled` flag
-// (registry default `true`) makes the PKB injector go silent — disable it
-// here so the v1 injection chain assertions stay meaningful.
-_setOverridesForTesting({ "memory-v2-enabled": false });
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// This test exercises v1 PKB injection. `config.memory.v2.enabled`
+// (default `true`) makes the PKB injector go silent — force it off here
+// so the v1 injection chain assertions stay meaningful.
+const realLoader = await import("../config/loader.js");
+const realGetConfig = realLoader.getConfig;
+mock.module("../config/loader.js", () => ({
+  ...realLoader,
+  getConfig: () => {
+    const real = realGetConfig();
+    return {
+      ...real,
+      memory: { ...real.memory, v2: { ...real.memory.v2, enabled: false } },
+    };
+  },
+}));
+
+const { applyRuntimeInjections, composeInjectorChain } = await import(
+  "../daemon/conversation-runtime-assembly.js"
+);
+const { DEFAULT_INJECTOR_ORDER, defaultInjectorsPlugin } = await import(
+  "../plugins/defaults/injectors.js"
+);
 import {
   getInjectors,
   registerPlugin,

package/src/__tests__/injector-pkb-v2-silenced.test.ts

@@ -1,23 +1,26 @@
 /**
  * v2 read-side cutover behavior for the PKB-derived default injectors.
  *
- * When `isMemoryV2ReadActive(getConfig())` is true:
+ * When `getConfig().memory.v2.enabled` is true:
  *   - `pkb-context` silences itself (concept pages own retrieval).
  *   - `pkb-reminder` still fires (its body is generic recall/remember
  *     guidance) but skips the PKB-search hints — those name PKB paths.
  *   - `now-md` fires unchanged (workspace state, independent of PKB).
  *
- * Mocks `isMemoryV2ReadActive` at the module level so each test can flip the
- * effective gate state without standing up a full feature-flag + config
- * stack. Mocks the PKB hybrid search so the reminder-with-hints branch can
- * resolve deterministically when called.
+ * Mocks `getConfig` at the module level so each test can flip the effective
+ * gate state without standing up a full config stack. Mocks the PKB hybrid
+ * search so the reminder-with-hints branch can resolve deterministically
+ * when called.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 let v2Active = false;
 
-mock.module("../memory/context-search/sources/memory-v2.js", () => ({
-  isMemoryV2ReadActive: () => v2Active,
+const realLoader = await import("../config/loader.js");
+
+mock.module("../config/loader.js", () => ({
+  ...realLoader,
+  getConfig: () => ({ memory: { v2: { enabled: v2Active } } }),
 }));
 
 mock.module("../memory/pkb/pkb-search.js", () => ({

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -1,17 +1,17 @@
 /**
- * Tests for the memory-v2 skill seed gate invoked from the daemon startup
- * path (`assistant/src/daemon/memory-v2-startup.ts`).
+ * Tests for the memory-v2 skill seed gate and the v2 concept-page schema
+ * rebuild gate, both invoked from the daemon startup path
+ * (`assistant/src/daemon/memory-v2-startup.ts`).
  *
- * The gate is exercised in isolation rather than mounting the full lifecycle
- * import graph. Coverage matrix from PR 8 acceptance criteria:
- *   - Case 1: feature flag on + `config.memory.v2.enabled` on → seed runs.
- *   - Case 2: feature flag off → seed does not run.
- *   - Case 3: `config.memory.v2.enabled` off (flag on) → seed does not run.
- *   - Case 4: `seedV2SkillEntries` rejects → gate does not throw and the
- *     warning is logged.
+ * The gates are exercised in isolation rather than mounting the full
+ * lifecycle import graph. Coverage matrix:
+ *   - Skill seed (`maybeSeedMemoryV2Skills`): config gating, rejection
+ *     swallowing.
+ *   - Schema rebuild (`maybeRebuildMemoryV2Concepts`): config gating,
+ *     drift-triggered reembed enqueue, empty-after-create reembed enqueue,
+ *     no enqueue when collection is healthy, error swallowing.
  *
- * The seed call itself is fire-and-forget (`void` + `.catch`); the gate must
- * never block startup or surface an exception.
+ * Both gates must never block startup or surface an exception.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -22,31 +22,36 @@ import type { AssistantConfig } from "../config/schema.js";
 // ---------------------------------------------------------------------------
 
 interface TestState {
-  flagOverrides: Record<string, boolean>;
   seedCallCount: number;
   seedShouldReject: Error | null;
   warnCalls: Array<{ obj: unknown; msg: unknown }>;
+  infoCalls: Array<{ obj: unknown; msg: unknown }>;
+  // Rebuild-gate mocks (drive maybeRebuildMemoryV2Concepts).
+  ensureCollectionCallCount: number;
+  ensureCollectionResult: { migrated: boolean };
+  ensureCollectionThrows: Error | null;
+  countResult: number;
+  listPagesResult: string[];
+  enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
 }
 
 const state: TestState = {
-  flagOverrides: {},
   seedCallCount: 0,
   seedShouldReject: null,
   warnCalls: [],
+  infoCalls: [],
+  ensureCollectionCallCount: 0,
+  ensureCollectionResult: { migrated: false },
+  ensureCollectionThrows: null,
+  countResult: 0,
+  listPagesResult: [],
+  enqueueCalls: [],
 };
 
 // ---------------------------------------------------------------------------
 // Mocks — installed before the module under test is loaded.
 // ---------------------------------------------------------------------------
 
-mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
-    const explicit = state.flagOverrides[key];
-    if (typeof explicit === "boolean") return explicit;
-    return true; // undeclared flags default to enabled
-  },
-}));
-
 mock.module("../memory/v2/skill-store.js", () => ({
   seedV2SkillEntries: async (): Promise<void> => {
     state.seedCallCount += 1;
@@ -54,18 +59,51 @@ mock.module("../memory/v2/skill-store.js", () => ({
   },
 }));
 
+mock.module("../memory/v2/qdrant.js", () => ({
+  ensureConceptPageCollection: async (): Promise<{ migrated: boolean }> => {
+    state.ensureCollectionCallCount += 1;
+    if (state.ensureCollectionThrows) throw state.ensureCollectionThrows;
+    return state.ensureCollectionResult;
+  },
+  countConceptPagePoints: async (): Promise<number> => state.countResult,
+  // The rebuild gate does not call this, but the seed gate's fire-and-forget
+  // chain imports it; provide a no-op so the dynamic import resolves.
+  dropLegacySkillsCollection: async (): Promise<void> => {},
+}));
+
+mock.module("../memory/v2/page-store.js", () => ({
+  hasConceptPages: async (): Promise<boolean> =>
+    state.listPagesResult.length > 0,
+}));
+
+mock.module("../memory/jobs-store.js", () => ({
+  enqueueMemoryJob: (
+    type: string,
+    payload: Record<string, unknown>,
+  ): string => {
+    state.enqueueCalls.push({ type, payload });
+    return "test-job-id";
+  },
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => "/tmp/test-workspace",
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () => ({
     warn: (obj: unknown, msg: unknown) => {
       state.warnCalls.push({ obj, msg });
     },
-    info: () => {},
+    info: (obj: unknown, msg: unknown) => {
+      state.infoCalls.push({ obj, msg });
+    },
     error: () => {},
     debug: () => {},
   }),
 }));
 
-const { maybeSeedMemoryV2Skills } =
+const { maybeSeedMemoryV2Skills, maybeRebuildMemoryV2Concepts } =
   await import("../daemon/memory-v2-startup.js");
 
 // ---------------------------------------------------------------------------
@@ -99,65 +137,37 @@ async function flushMicrotasks(): Promise<void> {
 // Tests
 // ---------------------------------------------------------------------------
 
+function resetState(): void {
+  state.seedCallCount = 0;
+  state.seedShouldReject = null;
+  state.warnCalls = [];
+  state.infoCalls = [];
+  state.ensureCollectionCallCount = 0;
+  state.ensureCollectionResult = { migrated: false };
+  state.ensureCollectionThrows = null;
+  state.countResult = 0;
+  state.listPagesResult = [];
+  state.enqueueCalls = [];
+}
+
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
-  beforeEach(() => {
-    state.flagOverrides = {};
-    state.seedCallCount = 0;
-    state.seedShouldReject = null;
-    state.warnCalls = [];
-  });
+  beforeEach(resetState);
 
-  test("invokes seedV2SkillEntries when flag and config are both enabled", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
+  test("invokes seedV2SkillEntries when memory.v2.enabled is true", async () => {
     maybeSeedMemoryV2Skills(makeConfig(true));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(1);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("does not invoke seedV2SkillEntries when feature flag is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("does not invoke seedV2SkillEntries when config.memory.v2.enabled is off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
-    maybeSeedMemoryV2Skills(makeConfig(false));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-    expect(state.warnCalls).toHaveLength(0);
-  });
-
-  test("does not invoke seedV2SkillEntries when both gates are off", async () => {
-    state.flagOverrides = { "memory-v2-enabled": false };
+  test("does not invoke seedV2SkillEntries when memory.v2.enabled is false", async () => {
     maybeSeedMemoryV2Skills(makeConfig(false));
     await flushMicrotasks();
     expect(state.seedCallCount).toBe(0);
     expect(state.warnCalls).toHaveLength(0);
   });
 
-  test("re-invocation seeds after flag flips on (deferred-init race recovery)", async () => {
-    // Models the lifecycle-startup race: the synchronous seed call evaluates
-    // the flag while the gateway IPC override fetch is still in flight, falls
-    // through to the registry default (`false`), and skips. Once
-    // `initFeatureFlagOverrides()` resolves, the chained `.then` re-invokes
-    // the seed with the now-populated cache and the flag flips to `true`.
-    state.flagOverrides = { "memory-v2-enabled": false };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(0);
-
-    state.flagOverrides = { "memory-v2-enabled": true };
-    maybeSeedMemoryV2Skills(makeConfig(true));
-    await flushMicrotasks();
-    expect(state.seedCallCount).toBe(1);
-  });
-
   test("swallows seedV2SkillEntries rejections and logs a warning", async () => {
-    state.flagOverrides = { "memory-v2-enabled": true };
     state.seedShouldReject = new Error("seed failed");
 
     // The gate must not throw — startup must not block on this.
@@ -172,3 +182,80 @@ describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
     expect(msg).toBe("Failed to seed v2 skill entries");
   });
 });
+
+describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
+  beforeEach(resetState);
+
+  test("does nothing when memory.v2.enabled is false", async () => {
+    await maybeRebuildMemoryV2Concepts(makeConfig(false));
+
+    expect(state.ensureCollectionCallCount).toBe(0);
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("enqueues memory_v2_reembed when the collection was migrated", async () => {
+    state.ensureCollectionResult = { migrated: true };
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.ensureCollectionCallCount).toBe(1);
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+    // Migrated path skips the count probe — drift detection is the trigger.
+    // (The mock's countConceptPagePoints would silently return 0 either way,
+    // but keeping the path conditional keeps the lifecycle hook predictable.)
+  });
+
+  test("enqueues reembed when the collection is empty but pages exist on disk (crash-mid-rebuild recovery)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = ["people/alice", "topics/zsh"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([
+      { type: "memory_v2_reembed", payload: {} },
+    ]);
+  });
+
+  test("does not enqueue when the collection is healthy and populated", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 1185;
+    state.listPagesResult = ["people/alice"];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("does not enqueue when the collection is empty AND no pages exist on disk (fresh workspace)", async () => {
+    state.ensureCollectionResult = { migrated: false };
+    state.countResult = 0;
+    state.listPagesResult = [];
+
+    await maybeRebuildMemoryV2Concepts(makeConfig(true));
+
+    expect(state.enqueueCalls).toEqual([]);
+  });
+
+  test("swallows ensureConceptPageCollection failures and logs a warning", async () => {
+    state.ensureCollectionThrows = new Error("Qdrant unreachable");
+
+    // Must not throw — startup never blocks on this gate.
+    let thrown: unknown = null;
+    try {
+      await maybeRebuildMemoryV2Concepts(makeConfig(true));
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeNull();
+
+    expect(state.enqueueCalls).toEqual([]);
+    expect(state.warnCalls.length).toBeGreaterThan(0);
+    const lastWarn = state.warnCalls[state.warnCalls.length - 1];
+    expect((lastWarn.obj as { err: Error }).err.message).toBe(
+      "Qdrant unreachable",
+    );
+  });
+});

package/src/__tests__/notification-decision-fallback.test.ts

@@ -95,6 +95,97 @@ describe("notification decision fallback copy", () => {
     );
   });
 
+  test("enforces guardian-facing popup copy for heartbeat alerts", async () => {
+    configuredProvider = { sendMessage: async () => ({}) };
+    extractedToolUse = {
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum"],
+        reasoningSummary: "Heartbeat found a useful follow-up.",
+        renderedCopy: {
+          vellum: {
+            title: "Heartbeat Follow-up",
+            body: "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          },
+        },
+        dedupeKey: "heartbeat:test",
+        confidence: 0.9,
+      },
+    };
+
+    const decision = await evaluateSignal(
+      makeSignal({
+        sourceEventName: "heartbeat.alert",
+        sourceChannel: "watcher",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      ["vellum"] as NotificationChannel[],
+    );
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.title).toBe("Heartbeat Alert");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "I found something worth your attention in a heartbeat check. Open the conversation for details.",
+    );
+    expect(decision.renderedCopy.vellum?.body).not.toContain(
+      "reminding the guardian",
+    );
+  });
+
+  test("keeps direct guardian-facing heartbeat copy", async () => {
+    configuredProvider = { sendMessage: async () => ({}) };
+    extractedToolUse = {
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum"],
+        reasoningSummary: "Heartbeat found a useful follow-up.",
+        renderedCopy: {
+          vellum: {
+            title: "Tracker Ready",
+            body: "Your daily tracker is ready. Review it before the next check-in.",
+          },
+        },
+        dedupeKey: "heartbeat:direct-copy-test",
+        confidence: 0.9,
+      },
+    };
+
+    const decision = await evaluateSignal(
+      makeSignal({
+        sourceEventName: "heartbeat.alert",
+        sourceChannel: "watcher",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      ["vellum"] as NotificationChannel[],
+    );
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.title).toBe("Tracker Ready");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "Your daily tracker is ready. Review it before the next check-in.",
+    );
+  });
+
   test("enforces free-text answer instructions for guardian.question when requestCode exists", async () => {
     const signal = makeSignal({
       contextPayload: {

package/src/__tests__/notification-decision-strategy.test.ts

@@ -373,6 +373,28 @@ describe("notification decision strategy", () => {
         "A guardian question needs your attention",
       );
     });
+
+    test("heartbeat.alert fallback avoids intermediary-instruction popup copy", () => {
+      const signal = makeSignal({
+        sourceEventName: "heartbeat.alert",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.title).toBe("Heartbeat Alert");
+      expect(copy.vellum!.body).toBe(
+        "I found something worth your attention in a heartbeat check. Open the conversation for details.",
+      );
+      expect(copy.vellum!.conversationSeedMessage).toContain(
+        "consider reminding the guardian",
+      );
+      expect(copy.telegram!.deliveryText).toBe(copy.vellum!.body);
+    });
   });
 
   // -- NotificationChannel type correctness ----------------------------------

package/src/__tests__/oauth-cli.test.ts

@@ -62,6 +62,13 @@ let mockUpsertAppImpl:
 let mockOrchestrateOAuthConnect: (
   opts: Record<string, unknown>,
 ) => Promise<Record<string, unknown>>;
+let mockCliIpcCall: (
+  operationId: string,
+  params?: Record<string, unknown>,
+) => Promise<Record<string, unknown>> = async () => ({
+  ok: false,
+  error: "Could not connect to assistant daemon (test default)",
+});
 let mockGetAppByProviderAndClientId: (
   provider: string,
   clientId: string,
@@ -335,6 +342,15 @@ mock.module("../oauth/connect-orchestrator.js", () => ({
     mockOrchestrateOAuthConnect(opts),
 }));
 
+// ---------------------------------------------------------------------------
+// Mock cli-client (IPC) — used by `oauth connect` for daemon-orchestrated flow
+// ---------------------------------------------------------------------------
+
+mock.module("../ipc/cli-client.js", () => ({
+  cliIpcCall: (operationId: string, params?: Record<string, unknown>) =>
+    mockCliIpcCall(operationId, params),
+}));
+
 mock.module("../oauth/seed-providers.js", () => ({
   SEEDED_PROVIDER_KEYS: new Set([
     "google",
@@ -1220,6 +1236,111 @@ describe("assistant oauth connect managed mode — platform 401/403 errors", ()
   });
 });
 
+// ---------------------------------------------------------------------------
+// `assistant oauth connect <provider>` BYO mode — daemon-unreachable behavior.
+//
+// We deleted the in-process `orchestrateOAuthConnect` fallback (the same
+// pattern as the MCP CLI consolidation in #29484). When the daemon is
+// unreachable, the CLI must surface a clear error and exit 1 — never
+// silently fall back to in-process flow.
+// ---------------------------------------------------------------------------
+
+describe("assistant oauth connect <provider> — daemon unreachable (BYO mode)", () => {
+  beforeEach(() => {
+    // BYO provider with a registered app and no managed-mode wiring.
+    mockGetProvider = () => ({
+      provider: "github",
+      authorizeUrl: "https://github.com/login/oauth/authorize",
+      tokenExchangeUrl: "https://github.com/login/oauth/access_token",
+      defaultScopes: "[]",
+      availableScopes: null,
+      authorizeParams: null,
+      managedServiceConfigKey: null,
+      requiresClientSecret: false,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    mockGetMostRecentAppByProvider = () => ({
+      provider: "github",
+      clientId: "test-client-id",
+      clientSecretCredentialPath: "oauth_app/github/test/client_secret",
+    });
+    mockGetSecureKey = () => "test-secret";
+    mockGetConfig = () => ({ services: {} });
+  });
+
+  test("daemon connect-refused → exit 1 with 'Is the assistant running?'", async () => {
+    mockCliIpcCall = async () => ({
+      ok: false,
+      error: "Could not connect to assistant daemon: ECONNREFUSED",
+    });
+
+    const { exitCode, stdout } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Could not reach the assistant");
+    expect(parsed.error).toContain("Is the assistant running?");
+  });
+
+  test("daemon route missing (Unknown method) → exit 1, never falls through to in-process", async () => {
+    let orchestratorCalls = 0;
+    mockOrchestrateOAuthConnect = async () => {
+      orchestratorCalls++;
+      return { success: true, deferred: false, grantedScopes: [] };
+    };
+    mockCliIpcCall = async () => ({
+      ok: false,
+      error: "Unknown method: internal_oauth_connect_start",
+    });
+
+    const { exitCode } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    // Critical regression guard: the in-process `orchestrateOAuthConnect`
+    // must NOT be invoked from the CLI. The daemon-orchestrated path is
+    // the sole code path; this is the same invariant #29484 established
+    // for the MCP CLI.
+    expect(orchestratorCalls).toBe(0);
+  });
+
+  test("daemon HTTP error (statusCode set) → surfaces error verbatim, no fallback", async () => {
+    let orchestratorCalls = 0;
+    mockOrchestrateOAuthConnect = async () => {
+      orchestratorCalls++;
+      return { success: true, deferred: false, grantedScopes: [] };
+    };
+    mockCliIpcCall = async () => ({
+      ok: false,
+      statusCode: 400,
+      error: "service must be registered before connecting",
+    });
+
+    const { exitCode, stdout } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.error).toContain("service must be registered");
+    expect(orchestratorCalls).toBe(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // requirePlatformClient — improved error messages
 // ---------------------------------------------------------------------------