@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/src/__tests__/agent-loop-mutable-latest-user-message.test.ts

@@ -1,14 +1,14 @@
 /**
- * Verifies that the `memory-v3-live` cache-anchor signal surfaces on every
- * `SendMessageOptions.config` the loop emits. When the flag is on, the latest
+ * Verifies that the memory-v3-live cache-anchor signal surfaces on every
+ * `SendMessageOptions.config` the loop emits. When v3-live is on, the latest
  * user message carries a volatile `<memory>` block, so the loop sets
  * `providerConfig.mutableLatestUserMessage` to tell the provider to anchor its
  * long-TTL cache breakpoint on the most recent STABLE message instead.
  *
- * The loop reads the flag directly where it assembles `providerConfig`, so the
- * signal is sourced from the flag rather than a run option. When the flag is
- * off the field is omitted (not `false`/`undefined`) so the wire stays
- * byte-identical to today.
+ * The loop reads `config.memory.v3.live` directly where it assembles
+ * `providerConfig`, so the signal is sourced from config rather than a run
+ * option. When v3-live is off the field is omitted (not `false`/`undefined`) so
+ * the wire stays byte-identical to today.
  */
 
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -19,11 +19,14 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+// AgentLoop reads the v3-live gate (`config.memory.v3.live`) via
+// `isMemoryV3Live` to decide the cache-anchor signal; drive it per-test.
+let memoryV3LiveSlot = false;
+mock.module("../config/memory-v3-gate.js", () => ({
+  isMemoryV3Live: () => memoryV3LiveSlot,
+}));
+
 import { AgentLoop } from "../agent/loop.js";
-import {
-  clearCachedOverrides,
-  setCachedOverrides,
-} from "../config/feature-flag-cache.js";
 import type {
   Message,
   Provider,
@@ -82,12 +85,12 @@ function makeRecordingProvider(responses: ProviderResponse[]): {
 
 describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () => {
   afterEach(() => {
-    clearCachedOverrides();
+    memoryV3LiveSlot = false;
   });
 
   test("sets mutableLatestUserMessage on every LLM call when memory-v3-live is on (multi-turn)", async () => {
     // GIVEN memory-v3-live is enabled
-    setCachedOverrides({ "memory-v3-live": true }, { fromGateway: true });
+    memoryV3LiveSlot = true;
 
     // AND a provider that records the config of each LLM call across a tool round-trip
     const { provider, configs } = makeRecordingProvider([
@@ -131,7 +134,7 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
 
   test("omits mutableLatestUserMessage when memory-v3-live is off (flag-off byte-identity)", async () => {
     // GIVEN memory-v3-live is off (no override; registry default is false)
-    clearCachedOverrides();
+    memoryV3LiveSlot = false;
 
     // AND a provider that records the config of each LLM call
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -365,6 +365,75 @@ describe("agent loop output hooks", () => {
     expect(calls[0].systemPrompt).toContain("[EDITED]");
   });
 
+  test("pre-model-call routes the call to the hook's chosen inference profile", async () => {
+    // GIVEN a hook that selects an inference profile for the user-facing call
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        if (ctx.callSite !== "mainAgent") return;
+        ctx.modelProfile = "fast-profile";
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    // WHEN the loop issues the user-facing provider call
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // THEN the provider call carries the hook's profile as the override
+    expect(calls[0].options?.config?.overrideProfile).toBe("fast-profile");
+  });
+
+  test("pre-model-call seeds modelProfile from the resolved override and clearing it drops the override", async () => {
+    // GIVEN a hook that observes the seeded override and then clears it
+    let seeded: string | null | undefined;
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        seeded = ctx.modelProfile;
+        ctx.modelProfile = null;
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    // WHEN the loop runs with an ad-hoc override profile
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      overrideProfile: "seed-profile",
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // THEN the hook saw the loop's resolved override
+    expect(seeded).toBe("seed-profile");
+    // AND clearing it sends no override on the provider call
+    expect(calls[0].options?.config?.overrideProfile).toBeUndefined();
+  });
+
+  // Context-window sizing and overflow recovery read the profile resolved
+  // before the hook runs, so a hook routing to a smaller-window profile does
+  // not resize the budget gate for that call. Tracked for a follow-up that
+  // resolves the routed profile ahead of the context-sizing gate.
+  test.todo(
+    "pre-model-call routing resizes the context-window budget for the routed profile",
+    () => {},
+  );
+
   test("fail-open: a hook that mutates in place AND then throws cannot corrupt the persisted content", async () => {
     // The hook mutates the array it receives before throwing. If the loop
     // handed the hook the real `assistantMessage.content` array, the

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -195,6 +195,7 @@ interface CapturedRunAgentLoopOptions {
   titleText?: string;
   callSite?: string;
   overrideProfile?: string;
+  forceOverrideProfile?: boolean;
 }
 
 const capturedRunAgentLoopOptions: CapturedRunAgentLoopOptions[] = [];
@@ -323,6 +324,29 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
     const captured = capturedRunAgentLoopOptions[0];
     expect(captured.callSite).toBe("subagentSpawn");
     expect(captured.overrideProfile).toBe("fast");
+    expect("forceOverrideProfile" in captured).toBe(false);
+  });
+
+  test("forwards forced overrideProfile from SubagentConfig into runAgentLoop", async () => {
+    capturedRunAgentLoopOptions.length = 0;
+
+    const manager = new SubagentManager();
+    await manager.spawn(
+      {
+        parentConversationId: "parent-forced",
+        label: "child",
+        objective: "do the thing",
+        overrideProfile: "fast",
+        forceOverrideProfile: true,
+      },
+      () => {},
+    );
+
+    expect(capturedRunAgentLoopOptions).toHaveLength(1);
+    const captured = capturedRunAgentLoopOptions[0];
+    expect(captured.callSite).toBe("subagentSpawn");
+    expect(captured.overrideProfile).toBe("fast");
+    expect(captured.forceOverrideProfile).toBe(true);
   });
 
   test("omits overrideProfile when SubagentConfig does not set it", async () => {
@@ -344,6 +368,7 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
     // Field must be absent rather than carrying `undefined`, mirroring the
     // agent loop's "field omitted when unset" contract.
     expect("overrideProfile" in captured).toBe(false);
+    expect("forceOverrideProfile" in captured).toBe(false);
   });
 });
 

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -28,7 +28,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 with recall occupying the existing slot", async () => {
+  test("should be exactly 10 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = getAllToolDefinitions();
 
@@ -52,7 +52,6 @@ describe("always-loaded tool count", () => {
     // path would allow unchecked host command execution.
     const expectedNames = [
       "bash",
-      "credential_store",
       "file_edit",
       "file_read",
       "file_write",
@@ -66,6 +65,6 @@ describe("always-loaded tool count", () => {
 
     expect(activeNames).toEqual(expectedNames);
     expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
-    expect(activeTools.length).toBe(11);
+    expect(activeTools.length).toBe(10);
   });
 });

package/src/__tests__/app-compiler.test.ts

@@ -2,9 +2,17 @@ import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  setDefaultTimeout,
+  test,
+} from "bun:test";
 
 import { compileApp } from "../bundler/app-compiler.js";
+import { ensureCompilerTools } from "../bundler/compiler-tools.js";
 import {
   ALLOWED_PACKAGES,
   getCacheDir,
@@ -19,8 +27,14 @@ import {
 
 let tempDir: string;
 
+// Compiler-tool download (esbuild + preact from npm) can take 10s+ on a cold
+// CI cache. Raise the file-level default so beforeAll isn't killed mid-install.
+// Each test file runs in its own process, so this doesn't leak.
+setDefaultTimeout(30_000);
+
 beforeAll(async () => {
   tempDir = await mkdtemp(join(tmpdir(), "app-compiler-test-"));
+  await ensureCompilerTools();
 });
 
 afterAll(async () => {

package/src/__tests__/app-dir-path-guard.test.ts

@@ -20,7 +20,6 @@ const ALLOWLIST = new Set([
   "assistant/src/memory/app-git-service.ts", // uses getAppsDir for git repo root, not per-app paths
   "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
   "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
-  "assistant/src/memory/preloaded-apps.ts", // seeds fixed-slug apps (id === dirName by construction) and writes the definition JSON, which app-store has no fixed-id helper for
 ]);
 
 function isTestFile(filePath: string): boolean {

package/src/__tests__/assistant-feature-flag-guard.test.ts

@@ -60,10 +60,7 @@ const CANONICAL_KEY_RE = /^[a-z0-9][a-z0-9-]*$/;
  * Keep this list minimal — only files that genuinely need to reference
  * the legacy format for backward compatibility.
  */
-const LEGACY_KEY_ALLOWLIST = new Set([
-  // macOS client: fallback reads from legacy config section
-  "clients/macos/vellum-assistant/Features/Settings/SettingsAccountTab.swift",
-]);
+const LEGACY_KEY_ALLOWLIST = new Set<string>([]);
 
 function isTestFile(filePath: string): boolean {
   return (

package/src/__tests__/assistant-feature-flag-guardrails.test.ts

@@ -58,8 +58,6 @@ function loadRegistry(): Registry {
 const LEGACY_KEY_ALLOWLIST = new Set([
   // Type definitions documenting the legacy format
   "assistant/src/config/types.ts",
-  // macOS client: fallback reads from legacy config section
-  "clients/macos/vellum-assistant/Features/Settings/SettingsAccountTab.swift",
 ]);
 
 function isTestFile(filePath: string): boolean {

package/src/__tests__/auth-fallback-events-store.test.ts

@@ -7,18 +7,10 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-let collectUsageData = true;
+let shareAnalytics = true;
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    secretDetection: { enabled: false },
-    collectUsageData,
-  }),
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
 }));
 
 import {
@@ -53,7 +45,7 @@ const SAMPLE: AuthFallbackCount[] = [
 
 describe("auth-fallback-events-store", () => {
   beforeEach(() => {
-    collectUsageData = true;
+    shareAnalytics = true;
     resetTable();
   });
 
@@ -78,8 +70,8 @@ describe("auth-fallback-events-store", () => {
     });
   });
 
-  test("honors the collectUsageData opt-out (records nothing)", () => {
-    collectUsageData = false;
+  test("honors the share_analytics opt-out (records nothing)", () => {
+    shareAnalytics = false;
     const recorded = recordAuthFallbackCounts(1000, 2000, SAMPLE);
     expect(recorded).toBe(0);
     expect(queryUnreportedAuthFallbackEvents(0, undefined, 100).length).toBe(0);

package/src/__tests__/avatar-identity-sync.test.ts

@@ -4,10 +4,7 @@ import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
-import {
-  publishIdentityChanged,
-  publishIdentityIntroChanged,
-} from "../runtime/sync/resource-sync-events.js";
+import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
 
 async function waitFor(predicate: () => boolean): Promise<void> {
   const deadline = Date.now() + 500;
@@ -81,29 +78,7 @@ describe("avatar and identity sync events", () => {
       });
       expect(received[1].message).toEqual({
         type: "sync_changed",
-        tags: [SYNC_TAGS.assistantIdentity, SYNC_TAGS.assistantIdentityIntro],
-      });
-    } finally {
-      subscription.dispose();
-    }
-  });
-
-  test("identity intro changes emit only the identity intro sync tag", async () => {
-    const received: AssistantEvent[] = [];
-    const subscription = assistantEventHub.subscribe({
-      type: "process",
-      callback: (event) => {
-        received.push(event);
-      },
-    });
-
-    try {
-      publishIdentityIntroChanged();
-      await waitFor(() => received.length === 1);
-
-      expect(received[0].message).toEqual({
-        type: "sync_changed",
-        tags: [SYNC_TAGS.assistantIdentityIntro],
+        tags: [SYNC_TAGS.assistantIdentity],
       });
     } finally {
       subscription.dispose();

package/src/__tests__/btw-routes.test.ts

@@ -78,10 +78,8 @@ mock.module("../prompts/persona-resolver.js", () => ({
   resolveUserSlug: () => null,
 }));
 
-mock.module("../runtime/routes/identity-intro-cache.js", () => ({
-  getCachedIntro: () => null,
-  readWorkspaceIdentityIntro: () => null,
-  setCachedIntro: () => {},
+mock.module("../runtime/routes/workspace-greetings.js", () => ({
+  readWorkspaceGreetings: () => null,
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
@@ -345,13 +343,13 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("emptyStateGreeting");
   });
 
-  test("identity intro requests pass callSite: 'identityIntro'", async () => {
+  test("generic requests pass the default callSite", async () => {
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
 
     const { result } = await callHandler({
-      conversationKey: "identity-intro",
+      conversationKey: "profile-intro",
       content: "Generate an intro",
     });
     await readStream(result as ReadableStream<Uint8Array>);
@@ -361,7 +359,7 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("identityIntro");
   });
 
-  test("identity intro requests do not synthesize a static name greeting", async () => {
+  test("generic requests do not synthesize a static name greeting", async () => {
     const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
     writeFileSync(
       identityPath,
@@ -375,7 +373,7 @@ describe("POST /v1/btw", () => {
       mockGetOrCreateConversation.mockImplementationOnce(async () => session);
 
       const { result } = await callHandler({
-        conversationKey: "identity-intro",
+        conversationKey: "profile-intro",
         content: "Generate an intro",
       });
       const text = await readStream(result as ReadableStream<Uint8Array>);

package/src/__tests__/call-pointer-messages.test.ts

@@ -343,6 +343,34 @@ describe("addPointerMessage", () => {
     expect(processorCalled).toBe(true);
   });
 
+  test("unverified_contact provenance round-trips through the metadata schema and is treated as trusted audience", async () => {
+    // Persisted unverified_contact metadata must survive the schema parse so
+    // downstream consumers (e.g. memory write gate, pointer audience trust)
+    // see the durable trust snapshot rather than a silently-dropped undefined.
+    const convId = "conv-ptr-uvc-provenance";
+    ensureConversation(convId);
+    await addMessage(convId, "user", "hello", {
+      metadata: { provenanceTrustClass: "unverified_contact" },
+    });
+
+    // Confirm the durable snapshot round-trips through the schema parser.
+    const { getConversationRecentProvenanceTrustClass } = await import(
+      "../memory/conversation-crud.js"
+    );
+    expect(getConversationRecentProvenanceTrustClass(convId)).toBe(
+      "unverified_contact",
+    );
+
+    // And that pointer-audience trust treats it identically to trusted_contact.
+    let processorCalled = false;
+    setPointerMessageProcessor(async () => {
+      processorCalled = true;
+    });
+
+    await addPointerMessage(convId, "completed", "+15559876543");
+    expect(processorCalled).toBe(true);
+  });
+
   test("unknown provenance trust class does not grant trusted audience", () => {
     const convId = "conv-ptr-unknown-provenance";
     ensureConversation(convId);

package/src/__tests__/cancel-clears-processing.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Cancel contract: a user cancel raises the conversation's AbortController and
+ * defers clearing the `processing` flag to the in-flight turn's `finally`.
+ *
+ * `cancelGeneration` no longer force-clears `processing` itself. Abort now
+ * propagates into the provider call and tool execution — and is backed by the
+ * agent loop's abort watchdog — so a cancelled turn always reaches its
+ * `finally` within a bounded time and tears down its own state there. The
+ * watchdog-driven path (turn reaches `finally`, processing clears) is covered
+ * by `conversation-agent-loop.test.ts`; this file pins the handler-side
+ * contract: cancel signals abort and leaves the flag to the turn.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { cancelGeneration } from "../daemon/handlers/conversations.js";
+
+interface CancelledConversation {
+  isProcessing: () => boolean;
+  setProcessingCalls: () => boolean[];
+  abortCount: () => number;
+}
+
+/**
+ * Register a conversation whose in-flight turn is processing. The fake records
+ * abort calls and any `setProcessing` writes so the test can assert that
+ * `cancelGeneration` signals abort without flipping the flag itself.
+ */
+function registerProcessingTurn(id: string): CancelledConversation {
+  let processing = true;
+  let abortCount = 0;
+  const setProcessingCalls: boolean[] = [];
+  const fake = {
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessingCalls.push(value);
+      processing = value;
+    },
+    abort: () => {
+      abortCount += 1;
+    },
+  };
+  setConversation(id, fake as unknown as Conversation);
+  return {
+    isProcessing: () => processing,
+    setProcessingCalls: () => setProcessingCalls,
+    abortCount: () => abortCount,
+  };
+}
+
+describe("cancelGeneration", () => {
+  const conversationId = "cancel-clears-processing-test-conversation";
+
+  afterEach(() => {
+    deleteConversation(conversationId);
+  });
+
+  test("raises abort and defers clearing processing to the turn's finally", () => {
+    // GIVEN a registered conversation that is processing
+    const fake = registerProcessingTurn(conversationId);
+    expect(fake.isProcessing()).toBe(true);
+
+    // WHEN the user cancels generation
+    const cancelled = cancelGeneration(conversationId);
+
+    // THEN the cancel is acknowledged
+    expect(cancelled).toBe(true);
+    // AND the abort signal is raised on the conversation
+    expect(fake.abortCount()).toBe(1);
+    // AND cancelGeneration does NOT force-clear the flag itself — the in-flight
+    // turn's `finally` owns that teardown once abort drives it there.
+    expect(fake.setProcessingCalls()).not.toContain(false);
+    expect(fake.isProcessing()).toBe(true);
+  });
+
+  test("returns false for a conversation that is not registered", () => {
+    // GIVEN no conversation registered under the id
+
+    // WHEN the user cancels generation for the unknown id
+    const cancelled = cancelGeneration("cancel-clears-processing-unknown-id");
+
+    // THEN the cancel reports that nothing was found
+    expect(cancelled).toBe(false);
+  });
+});

package/src/__tests__/channel-approval-routes.test.ts

@@ -224,14 +224,12 @@ function ensureTestContact(): void {
       {
         type: "telegram",
         address: "telegram-user-default",
-        externalUserId: "telegram-user-default",
         status: "active",
         policy: "allow",
       },
       {
         type: "slack",
         address: "slack-user-default",
-        externalUserId: "slack-user-default",
         status: "active",
         policy: "allow",
       },
@@ -2054,7 +2052,6 @@ describe("requester cancel of guardian-gated pending request", () => {
         {
           type: "telegram",
           address: "requester-cancel-user",
-          externalUserId: "requester-cancel-user",
           status: "active",
           policy: "allow",
         },
@@ -2981,7 +2978,6 @@ describe("trusted-contact self-approval blocked before guardian approval row exi
         {
           type: "telegram",
           address: "tc-selfapproval-user",
-          externalUserId: "tc-selfapproval-user",
           status: "active",
           policy: "allow",
         },

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -97,7 +97,6 @@ function seedTrustedContact(policy: "allow" | "escalate" = "allow"): void {
       {
         type: "telegram",
         address: "telegram-user-1",
-        externalUserId: "telegram-user-1",
         status: "active",
         policy,
       },
@@ -237,14 +236,13 @@ describe("channel inbound disk pressure gate", () => {
     expect(db.select().from(messages).all()).toHaveLength(0);
   });
 
-  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+  test("blocks non-guardian Slack reactions silently (no reply) before persistence while locked", async () => {
     upsertContact({
       displayName: "Example Slack User",
       channels: [
         {
           type: "slack",
           address: "slack-user-1",
-          externalUserId: "slack-user-1",
           status: "active",
           policy: "allow",
         },
@@ -276,18 +274,10 @@ describe("channel inbound disk pressure gate", () => {
       reason: "trusted-contact",
     });
     expect(processMessage).not.toHaveBeenCalled();
-    expect(deliverChannelReplyMock.mock.calls).toEqual([
-      [
-        "https://gateway.test/deliver/slack",
-        {
-          chatId: "slack-channel-1",
-          text: expectedRemoteBlockReply,
-          assistantId: "self",
-          ephemeral: true,
-          user: "slack-user-1",
-        },
-      ],
-    ]);
+    // Reactions are blocked silently during disk pressure: a passive signal
+    // has nothing to "try again", so no block reply is delivered (unlike the
+    // message path, which does reply).
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
 
     const db = getDb();
     const event = db

package/src/__tests__/checker.test.ts

@@ -790,9 +790,6 @@ describe("Permission Checker", () => {
       const workingDir = join(homedir(), "projects", "myapp");
       expect(generateScopeOptions(workingDir, "web_fetch")).toHaveLength(0);
       expect(generateScopeOptions(workingDir, "skill_load")).toHaveLength(0);
-      expect(generateScopeOptions(workingDir, "credential_store")).toHaveLength(
-        0,
-      );
       expect(
         generateScopeOptions(workingDir, "computer_use_click"),
       ).toHaveLength(0);

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -52,7 +52,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 const { registerMemoryV2Command } =
-  await import("../cli/commands/memory-v2.js");
+  await import("../cli/commands/memory/memory-v2.js");
 const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
   await import("../runtime/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
@@ -68,9 +68,8 @@ function buildProgram(): Command {
     writeErr: () => {},
     writeOut: () => {},
   });
-  // The registrar creates the `memory` parent itself, so callers don't
-  // need to stub one.
-  registerMemoryV2Command(program);
+  const memory = program.command("memory");
+  registerMemoryV2Command(memory);
   return program;
 }