@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/__tests__/actor-trust-resolver-address-fallback.test.ts

@@ -1,16 +1,14 @@
 /**
- * Tests for the address-fallback path in resolveActorTrust.
+ * Tests for address-based member resolution in resolveActorTrust.
  *
- * Phone channels registered by the inbound name-capture flow have `address`
- * set (E.164) but `externalUserId` = NULL until DTMF verification completes.
- * The primary `findContactByChannelExternalId` lookup misses these channels,
- * which historically caused the relay router to fall into the name-capture
- * ("I don't recognize this number") path instead of the unverified-caller
- * guidance path.
+ * All member lookups use the canonical (type, address) path — the address
+ * column is the sole identity for all channel types. Phone channels
+ * registered by the inbound name-capture flow have `address` set (E.164)
+ * and are discovered through the same path as every other channel.
  *
- * This suite verifies that the address-based fallback fires correctly and
- * that the returned `memberRecord` carries the right channel/status so
- * relay-setup-router can emit the `unverified_caller` outcome.
+ * This suite verifies that address-based lookup returns the correct
+ * `memberRecord` with the right channel/status so relay-setup-router
+ * can emit the appropriate outcome (e.g. `unverified_caller`).
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -22,18 +20,14 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // ── Contact store stubs — filled in per test ─────────────────────────────────
-let _byExternalId: ReturnType<
-  typeof import("../contacts/contact-store.js")["findContactByChannelExternalId"]
-> = null;
 let _byAddress: ReturnType<
-  typeof import("../contacts/contact-store.js")["findContactByAddress"]
+  (typeof import("../contacts/contact-store.js"))["findContactByAddress"]
 > = null;
 let _guardian: ReturnType<
-  typeof import("../contacts/contact-store.js")["findGuardianForChannel"]
+  (typeof import("../contacts/contact-store.js"))["findGuardianForChannel"]
 > = null;
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByChannelExternalId: (_type: string, _id: string) => _byExternalId,
   findContactByAddress: (_type: string, _addr: string) => _byAddress,
   findGuardianForChannel: (_channel: string) => _guardian,
 }));
@@ -69,7 +63,7 @@ function makeContact(
         id: channelId,
         contactId: "contact-test",
         type: "phone",
-        address: PHONE.toLowerCase(),
+        address: PHONE,
         externalUserId,
         externalChatId: null,
         isPrimary: true,
@@ -94,7 +88,6 @@ function makeContact(
 
 describe("resolveActorTrust — address fallback", () => {
   beforeEach(() => {
-    _byExternalId = null;
     _byAddress = null;
     _guardian = null;
   });
@@ -117,12 +110,8 @@ describe("resolveActorTrust — address fallback", () => {
     expect(result.trustClass).toBe("unknown");
   });
 
-  test("externalUserId path takes priority over address path", () => {
-    // Both lookups return a contact; the externalUserId one should win.
-    const primaryContact = makeContact("contact", "active", PHONE);
-    const addressContact = makeContact("contact", "unverified", null);
-    _byExternalId = primaryContact;
-    _byAddress = addressContact;
+  test("address lookup is the sole member resolution path", () => {
+    _byAddress = makeContact("contact", "active", null);
 
     const result = resolveActorTrust({
       assistantId: "asst-1",
@@ -132,11 +121,10 @@ describe("resolveActorTrust — address fallback", () => {
     });
 
     expect(result.memberRecord?.channel.status).toBe("active");
-    expect(result.memberRecord?.channel.externalUserId).toBe(PHONE);
+    expect(result.memberRecord?.channel.address).toBe(PHONE);
   });
 
   test("returns null memberRecord when neither lookup finds the number", () => {
-    _byExternalId = null;
     _byAddress = null;
 
     const result = resolveActorTrust({

package/src/__tests__/agent-loop-compaction-strip.test.ts

@@ -0,0 +1,240 @@
+/**
+ * The compaction summarizer's input routing.
+ *
+ * Budget-gate compaction summarizes the *injected* history so the summary
+ * call's prompt prefix matches the agent's warm prefix cache (a cache read
+ * rather than a fresh cache write). Overflow recovery summarizes the
+ * injection-*stripped* history because its emergency split keeps an
+ * un-stripped verbatim prefix that the post-compaction re-injection would
+ * otherwise double-stack.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { PostCompactContext } from "@vellumai/plugin-api";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type { ContextWindowConfig } from "../config/types.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import {
+  createContextWindowManager,
+  disposeContextWindowManager,
+  getContextWindowManager,
+} from "../plugins/defaults/compaction/manager-store.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import { ContextOverflowError } from "../providers/types.js";
+
+const testPostCompactPlugin = {
+  manifest: { name: "test-post-compact", version: "0.0.0" },
+  hooks: {
+    [HOOKS.POST_COMPACT]: async (input: PostCompactContext): Promise<void> => {
+      void input;
+    },
+  },
+};
+
+const CONVERSATION_ID = "compaction-strip-conversation";
+
+/**
+ * A runtime `<workspace>` injection block. `stripInjectionsForCompaction`
+ * matches its full `{ prefix: "<workspace>\n", suffix: "\n</workspace>" }`
+ * wrapper and drops it from user-message content.
+ */
+const WORKSPACE_INJECTION =
+  "<workspace>\nActive workspace: project-x\n</workspace>";
+const TURN_BODY = "Hello there, this is the turn body.";
+
+/**
+ * A user turn carrying a real text block plus a runtime injection block.
+ * Stripping drops the injection block and keeps the real one.
+ */
+const injectedUserMessage: Message = {
+  role: "user",
+  content: [
+    { type: "text", text: TURN_BODY },
+    { type: "text", text: WORKSPACE_INJECTION },
+  ],
+};
+
+function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+function createMockProvider(responses: ProviderResponse[]): Provider {
+  let callIndex = 0;
+  return {
+    name: "mock",
+    async sendMessage(
+      _messages: Message[],
+      _options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      const response = responses[callIndex] ?? responses[responses.length - 1];
+      callIndex++;
+      return response;
+    },
+  };
+}
+
+interface CompactionInputCapture {
+  budget: Message[] | null;
+  overflow: Message[] | null;
+}
+
+/**
+ * Install a per-conversation manager that records the messages handed to the
+ * budget summarizer (`maybeCompact`) and to overflow recovery
+ * (`recoverContextOverflow`).
+ */
+function installCapturingManager(capture: CompactionInputCapture): {
+  trust: TrustContext;
+} {
+  createContextWindowManager({
+    provider: { name: "mock-provider" } as unknown as Provider,
+    systemPrompt: "system",
+    config: {} as unknown as ContextWindowConfig,
+    conversationId: CONVERSATION_ID,
+  });
+  const manager = getContextWindowManager(CONVERSATION_ID);
+  if (manager) {
+    manager.maybeCompact = (async (messages: Message[]) => {
+      capture.budget = messages;
+      return {
+        messages: [injectedUserMessage],
+        compacted: true,
+        exhausted: false,
+      };
+    }) as unknown as typeof manager.maybeCompact;
+    manager.recoverContextOverflow = (async (messages: Message[]) => {
+      capture.overflow = messages;
+      return {
+        messages: [injectedUserMessage],
+        compacted: true,
+        exhausted: false,
+      };
+    }) as unknown as typeof manager.recoverContextOverflow;
+  }
+  return { trust: { sourceChannel: "vellum", trustClass: "unknown" } };
+}
+
+function serialize(messages: Message[] | null): string {
+  return JSON.stringify(messages ?? []);
+}
+
+describe("AgentLoop compaction summarizer input", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(testPostCompactPlugin);
+  });
+
+  afterEach(() => {
+    disposeContextWindowManager(CONVERSATION_ID);
+  });
+
+  test("budget-gate compaction summarizes the injected history", async () => {
+    // GIVEN a history whose user turn carries a runtime-injection block
+    const capture: CompactionInputCapture = { budget: null, overflow: null };
+    const provider = createMockProvider([
+      textResponse("done after compaction"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    const events: AgentEvent[] = [];
+
+    // WHEN the budget gate trips and in-place compaction runs
+    await loop.run({
+      requestId: "req",
+      messages: [injectedUserMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installCapturingManager(capture),
+    });
+
+    // THEN the budget summarizer received the injected history, injection intact
+    expect(capture.budget).not.toBeNull();
+    expect(serialize(capture.budget)).toContain("<workspace>");
+    // AND overflow recovery was not invoked
+    expect(capture.overflow).toBeNull();
+    // AND the history-stripped marker still fires for the durable base
+    expect(events.some((e) => e.type === "history_stripped")).toBe(true);
+  });
+
+  test("overflow-driven compaction summarizes the injection-stripped history", async () => {
+    // GIVEN a history whose user turn carries a runtime-injection block
+    const capture: CompactionInputCapture = { budget: null, overflow: null };
+
+    // AND a provider that rejects the first call as context-too-large
+    let throwOnce = true;
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        if (throwOnce) {
+          throwOnce = false;
+          throw new ContextOverflowError("prompt too long", "mock", {
+            actualTokens: 999_999,
+          });
+        }
+        return textResponse("done after overflow recovery");
+      },
+    };
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    // A blocking watermark plus `compactInPlace: false` keep the budget gate
+    // from firing, so only the overflow rejection drives compaction.
+    loop.compactionCircuit.lastPostCompactionEstimate = 0;
+    const events: AgentEvent[] = [];
+
+    // WHEN the provider overflow forces overflow recovery
+    await loop.run({
+      requestId: "req",
+      messages: [injectedUserMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: false,
+      ...installCapturingManager(capture),
+    });
+
+    // THEN overflow recovery received the history with the injection removed
+    expect(capture.overflow).not.toBeNull();
+    expect(serialize(capture.overflow)).not.toContain("<workspace>");
+    // AND the real turn body survives the strip
+    expect(serialize(capture.overflow)).toContain(TURN_BODY);
+    // AND the budget summarizer was not invoked
+    expect(capture.budget).toBeNull();
+  });
+});

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-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__/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__/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);