@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/daemon/memory-v2-startup.ts

@@ -49,6 +49,36 @@ export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
     .catch((err) => log.warn({ err }, "Failed to seed v2 CLI-command entries"));
 }
 
+/**
+ * Default upper bound on how long
+ * {@link maybeReseedCapabilitiesAfterManagedCredential} waits for the capability
+ * reseeds before enqueuing the v3 maintain pass. The reseeds keep running
+ * detached past this bound — it only stops the barrier from waiting on a wedged
+ * catalog (a stalled `getCatalog()` or a managed-proxy embed that never
+ * returns). A straggler that finishes later re-enqueues maintain.
+ */
+const RESEED_BARRIER_TIMEOUT_MS = 120_000;
+
+/**
+ * Resolve to `true` if `p` settles within `ms`, or `false` if the timeout wins.
+ * Always clears the timer, so a `p` that settles first leaves no pending timer
+ * keeping the event loop (or a test) alive.
+ */
+async function settledWithin(
+  p: Promise<unknown>,
+  ms: number,
+): Promise<boolean> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<false>((resolve) => {
+    timer = setTimeout(() => resolve(false), ms);
+  });
+  try {
+    return await Promise.race([p.then(() => true), timedOut]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 /**
  * Re-seed the v2 skill and CLI-command capability entries once a managed-proxy
  * credential lands, closing the first-boot race where the daemon's startup seed
@@ -83,9 +113,23 @@ export function maybeSeedMemoryV2CliCommands(config: AssistantConfig): void {
  * dense store and its lane-invalidation stage forces a rebuild against the now-
  * populated index, so v3 surfaces the skill/CLI pages within seconds instead of
  * waiting out the backstop.
+ *
+ * The maintain enqueue must NOT be gated on both catalogs settling. The two
+ * embeds are independent, and a single wedged catalog (a stalled `getCatalog()`
+ * or a managed-proxy embed that never returns) would otherwise block the v3 lane
+ * rebuild indefinitely, so the catalog that DID seed never reaches the selector.
+ * The barrier is therefore bounded by `reseedTimeoutMs`: maintain is enqueued
+ * once the barrier resolves (the pass is idempotent and reconciles whatever the
+ * page index currently holds), and a straggler catalog that finishes after the
+ * timeout re-enqueues maintain so its late rows are picked up without waiting out
+ * the backstop.
+ *
+ * `reseedTimeoutMs` is injectable for tests; production uses
+ * {@link RESEED_BARRIER_TIMEOUT_MS}.
  */
 export async function maybeReseedCapabilitiesAfterManagedCredential(
   config: AssistantConfig,
+  opts: { reseedTimeoutMs?: number } = {},
 ): Promise<void> {
   if (!config.memory.v2.enabled) return;
 
@@ -115,35 +159,59 @@ export async function maybeReseedCapabilitiesAfterManagedCredential(
     ],
   ];
 
-  await Promise.all(
-    catalogs.map(async ([label, seed]) => {
-      try {
-        await seed();
+  // Each reseed is contained so one catalog's embed failure (or hang) never
+  // rejects the caller or aborts the other. Started here but not awaited as a
+  // single barrier — the bounded wait below decides when to stop waiting.
+  const reseeds = catalogs.map(([label, seed]) =>
+    seed().then(
+      () =>
         log.info(
           `Memory v2 ${label} entries seeded after managed proxy credential update`,
-        );
-      } catch (err) {
+        ),
+      (err: unknown) =>
         log.warn(
           { err },
           `Failed to seed v2 ${label} entries after managed proxy credential update`,
-        );
-      }
-    }),
+        ),
+    ),
   );
 
-  // The stores (and the page index) are now populated; when v3 is live, kick a
-  // maintain pass so it embeds the capability rows into `memory_v3_sections` and
-  // invalidates its lanes immediately rather than waiting out the 6h backstop.
+  // When v3 is live, a maintain pass embeds the freshly-seeded capability rows
+  // into `memory_v3_sections` and invalidates the lanes so v3 surfaces the
+  // skill/CLI pages within seconds instead of waiting out the 6h backstop.
+  // Resolve the gate + enqueuer once and reuse for the post-barrier enqueue and
+  // the straggler re-enqueue below.
   const { isMemoryV3Live } = await import("../config/memory-v3-gate.js");
-  if (!isMemoryV3Live(config)) return;
-  try {
-    const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
-    enqueueMemoryJob("memory_v3_maintain", {});
-  } catch (err) {
+  const v3Live = isMemoryV3Live(config);
+  const enqueueMaintain = async (): Promise<void> => {
+    if (!v3Live) return;
+    try {
+      const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
+      enqueueMemoryJob("memory_v3_maintain", {});
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+      );
+    }
+  };
+
+  // Bound the barrier so a wedged catalog can't block the maintain enqueue
+  // indefinitely; the reseeds keep running detached past the timeout.
+  const timeoutMs = opts.reseedTimeoutMs ?? RESEED_BARRIER_TIMEOUT_MS;
+  const allReseeds = Promise.allSettled(reseeds);
+  const settledInTime = await settledWithin(allReseeds, timeoutMs);
+
+  await enqueueMaintain();
+
+  if (!settledInTime) {
     log.warn(
-      { err },
-      "Failed to enqueue memory_v3_maintain after managed proxy credential update",
+      { timeoutMs },
+      "Capability reseed still running after the barrier timeout — enqueued v3 maintain now; will re-enqueue when the straggler catalog finishes",
     );
+    // The straggler is still embedding; re-enqueue maintain once it lands so its
+    // late capability rows are reconciled without waiting out the 6h backstop.
+    void allReseeds.then(() => enqueueMaintain());
   }
 }
 

package/src/daemon/message-types/inbox.ts

@@ -23,12 +23,6 @@ export interface ContactsInviteRequest {
   externalChatId?: string;
   /** Filter by status (list only). */
   status?: string;
-  /** Invitee's first name (voice invite create only). */
-  friendName?: string;
-  /** Contact display name for personalizing invite instructions (create only). */
-  contactName?: string;
-  /** Guardian's first name (voice invite create only). */
-  guardianName?: string;
 }
 
 export interface AssistantInboxEscalationRequest {

package/src/daemon/message-types/messages.ts

@@ -22,7 +22,6 @@ import type {
   TraceEvent,
   TraceEventKind,
 } from "../../api/events/trace-event.js";
-import type { TurnProfileAutoRoutedEvent } from "../../api/events/turn-profile-auto-routed.js";
 import type { UserMessageEchoEvent } from "../../api/events/user-message-echo.js";
 import type { ChannelId, InterfaceId } from "../../channels/types.js";
 import type { CommandIntent, UserMessageAttachment } from "./shared.js";
@@ -122,8 +121,6 @@ export interface ConfirmationStateChanged {
   toolUseId?: string;
 }
 
-export type { TurnProfileAutoRoutedEvent };
-
 /**
  * Broadcast to clients when a conversation's inference-profile override
  * changes. `profile` is the profile name (a key in `llm.profiles`) or
@@ -172,6 +169,5 @@ export type _MessagesServerMessages =
   | TraceEvent
   | ConfirmationStateChanged
   | AssistantActivityStateEvent
-  | TurnProfileAutoRoutedEvent
   | ConversationInferenceProfileUpdated
   | InteractionResolvedEvent;

package/src/daemon/message-types/surfaces.ts

@@ -1,5 +1,17 @@
 // Surface types, UI surface lifecycle messages.
 
+import {
+  type CardSurfaceData,
+  CardSurfaceDataSchema,
+} from "../../api/surfaces.js";
+
+// Surface `data` shapes are wire payloads owned by `@vellumai/assistant-api`.
+// Card is migrated (canonical Zod schema); the remaining types below are still
+// hand-written interfaces pending migration. Re-exported so the daemon's
+// surface protocol barrel (`message-protocol.ts`) keeps surfacing them to
+// daemon consumers under their canonical names.
+export { type CardSurfaceData, CardSurfaceDataSchema };
+
 // === Surface type definitions ===
 
 export type SurfaceType =
@@ -35,17 +47,6 @@ export interface SurfaceAction {
   data?: Record<string, unknown>;
 }
 
-export interface CardSurfaceData {
-  title: string;
-  subtitle?: string;
-  body: string;
-  metadata?: Array<{ label: string; value: string }>;
-  /** Optional template name for specialized rendering (e.g. "weather_forecast"). */
-  template?: string;
-  /** Arbitrary data consumed by the template renderer. Shape depends on template. */
-  templateData?: Record<string, unknown>;
-}
-
 export interface ChoiceOption {
   id: string;
   title: string;

package/src/daemon/server.ts

@@ -47,7 +47,6 @@ import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
-import { PluginSourceWatcher } from "./plugin-source-watcher.js";
 import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 import { WorkspaceToolsWatcher } from "./workspace-tools-watcher.js";
 
@@ -84,7 +83,6 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = getConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
-  private pluginSourceWatcher = PluginSourceWatcher.getInstance();
   private cliIpc = new AssistantIpcServer();
   private skillIpc = new SkillIpcServer();
 
@@ -310,7 +308,6 @@ export class DaemonServer {
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
-    this.pluginSourceWatcher.start();
     WorkspaceToolsWatcher.getInstance().start();
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
@@ -327,7 +324,6 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
-    this.pluginSourceWatcher.stop();
     WorkspaceToolsWatcher.getInstance().stop();
     this.cliIpc.stop();
     this.skillIpc.stop();

package/src/daemon/shutdown-handlers.ts

@@ -5,6 +5,7 @@ import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { McpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db-connection.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
+import { stopMemoryWorkerProcess } from "../memory/worker-control.js";
 import type { RuntimeHttpServer } from "../runtime/http-server.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
@@ -117,8 +118,27 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
+
+    // Stop the in-process memory worker if one was started on the daemon's
+    // event loop (memory.worker.enabled = false).
     deps.getMemoryWorker()?.stop();
 
+    // Stop the out-of-process memory worker if it's actually running. This is
+    // keyed off live state rather than config: the worker may have been
+    // spawned at startup (memory.worker.enabled = true) or out of band via
+    // `assistant memory worker start`, so we stop whatever is actually there.
+    try {
+      const workerStatus = stopMemoryWorkerProcess();
+      if (workerStatus.status === "running") {
+        log.info(
+          { pid: workerStatus.pid },
+          "Sent SIGTERM to memory worker process",
+        );
+      }
+    } catch (err) {
+      log.warn({ err }, "Failed to stop memory worker process (non-fatal)");
+    }
+
     if (deps.mcpManager) {
       try {
         await deps.mcpManager.stop();

package/src/daemon/tool-setup-types.ts

@@ -125,10 +125,12 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    */
   currentTurnOverrideProfile?: string;
   /**
-   * Set by the `switch_inference_profile` tool when the model self-selects a
-   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
-   * agent loop so the next LLM call uses the switched profile. Reset at
-   * turn start.
+   * Whether the current turn has no human present to answer clarification
+   * prompts. Resolved once per turn by the agent loop — honoring an explicit
+   * per-run `isInteractive` option (e.g. scheduled/background turns) over the
+   * live client state — so tool execution sees turn-level interactivity rather
+   * than re-deriving it from `hasNoClient`/`headlessLock`, which would read a
+   * scheduled turn running on a client-attached conversation as interactive.
    */
-  toolRoutedProfile?: string;
+  currentTurnIsNonInteractive?: boolean;
 }

package/src/daemon/trust-context.ts

@@ -38,6 +38,12 @@ export interface TrustContext {
   requesterExternalUserId?: string;
   /** Chat/conversation ID the requester is interacting through. */
   requesterChatId?: string;
+  /** Contact ID of the requester's member record, for local info joins. */
+  requesterContactId?: string;
+  /** API-facing member status of the requester's channel (ACL). */
+  memberStatus?: string;
+  /** Channel policy of the requester's channel (ACL). */
+  memberPolicy?: string;
 }
 
 /**

package/src/daemon/wake-conversation-ops.ts

@@ -22,6 +22,7 @@ import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { Message } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import type { ServerMessage } from "./message-protocol.js";
@@ -147,6 +148,7 @@ function translateAgentEventToServerMessage(
     case "compaction_completed":
     case "history_stripped":
     case "agent_loop_exit":
+    case "system_prompt_changed":
       return null;
     case "llm_call_started":
       // The wake path persists its assistant tail via
@@ -255,6 +257,74 @@ export async function persistWakeTailMessage(
   }
 }
 
+/**
+ * Persist a wake's trigger as a single visible user message — the
+ * append-only counterpart to the legacy ephemeral hint injection. Keeping the
+ * trigger in durable history (instead of splicing a non-persisted message per
+ * wake) lets the provider prompt-cache treat repeated wakes like normal user
+ * turns rather than re-creating the whole prefix each time.
+ *
+ * Mirrors {@link persistWakeTailMessage}'s channel/interface/provenance
+ * metadata, but stamps `kind: "background-event"` (+ the originating `source`)
+ * for identification, skips indexing (the body may carry untrusted command
+ * output), and is NOT flagged hidden so the trigger shows in the transcript.
+ */
+export async function persistWakeTriggerMessage(
+  conversation: Conversation,
+  message: Message,
+  source: string,
+): Promise<void> {
+  const turnChannelCtx = conversation.getTurnChannelContext();
+  const turnInterfaceCtx = conversation.getTurnInterfaceContext();
+  const metadata: Record<string, unknown> = {
+    ...provenanceFromTrustContext(conversation.trustContext),
+    userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
+    assistantMessageChannel:
+      turnChannelCtx?.assistantMessageChannel ?? "vellum",
+    userMessageInterface: turnInterfaceCtx?.userMessageInterface ?? "web",
+    assistantMessageInterface:
+      turnInterfaceCtx?.assistantMessageInterface ?? "web",
+    kind: "background-event",
+    backgroundEventSource: source,
+    automated: true,
+  };
+  const persisted = await addMessage(
+    conversation.conversationId,
+    message.role,
+    JSON.stringify(message.content),
+    { metadata, skipIndexing: true },
+  );
+  try {
+    const convRow = getConversation(conversation.conversationId);
+    if (convRow) {
+      syncMessageToDisk(
+        conversation.conversationId,
+        persisted.id,
+        convRow.createdAt,
+      );
+    }
+  } catch (err) {
+    log.warn(
+      { err, conversationId: conversation.conversationId },
+      "wake trigger persist: syncMessageToDisk failed (non-fatal)",
+    );
+  }
+  // Tell connected clients the message list changed so they refetch and the
+  // visible trigger renders live. The normal user-send path publishes the same
+  // invalidation after persisting a user message; without it a wake that
+  // produces no assistant stream (silent no-op), or a conversation open in
+  // another client, would not show the <background_event> row until a manual
+  // reload.
+  try {
+    publishConversationMessagesChanged(conversation.conversationId);
+  } catch (err) {
+    log.warn(
+      { err, conversationId: conversation.conversationId },
+      "wake trigger persist: publishConversationMessagesChanged failed (non-fatal)",
+    );
+  }
+}
+
 /**
  * Temporarily restrict the tools visible/executable during a wake by
  * reusing the conversation's subagent allowlist slot. Returns a restore

package/src/daemon/workspace-tools-watcher.ts

@@ -23,9 +23,9 @@
  * the world: "given what's on disk right now for `<stem>.*`, what
  * registry state should the assistant be in?"
  *
- * This is the same eventual-consistency pattern as
- * `plugin-source-watcher.ts` — the watcher exists to KICK the
- * reconciler, not to be the source of truth about what changed.
+ * This is the same eventual-consistency pattern the plugin mtime cache
+ * uses — the watcher exists to KICK the reconciler, not to be the
+ * source of truth about what changed.
  *
  * ## Lifecycle position
  *
@@ -57,6 +57,7 @@ import {
   loadSingleWorkspaceTool,
 } from "../tools/workspace-tools/loader.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceToolsDir } from "../util/platform.js";
 
@@ -154,6 +155,9 @@ export class WorkspaceToolsWatcher {
           });
         },
       );
+      // Async FSWatcher errors (e.g. ENOSPC, ENXIO) arrive as an 'error' event;
+      // without a listener they crash the daemon. Degrade to a dead watcher.
+      attachFsWatcherErrorHandler(this.watcher, log, toolsDir);
       log.info({ toolsDir }, "Workspace tools watcher started");
     } catch (err) {
       log.warn(

package/src/documents/document-comments-store.test.ts

@@ -18,7 +18,7 @@ import {
   resolveComment,
 } from "./document-comments-store.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/heartbeat/__tests__/heartbeat-run-store.test.ts

@@ -25,7 +25,7 @@ import {
   supersedePendingRun,
 } from "../heartbeat-run-store.js";
 
-initializeDb();
+await initializeDb();
 
 describe("heartbeat-run-store", () => {
   beforeEach(() => {

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -88,6 +88,9 @@ const stubConfig: {
     maxDailyRuns: number | null;
     disposition: string;
   };
+  timeouts: {
+    backgroundTurnTimeoutSec: number;
+  };
 } = {
   heartbeat: {
     enabled: true,
@@ -98,6 +101,9 @@ const stubConfig: {
     maxDailyRuns: null,
     disposition: "Default disposition text.",
   },
+  timeouts: {
+    backgroundTurnTimeoutSec: 1800,
+  },
 };
 mock.module("../../config/loader.js", () => ({
   getConfig: () => stubConfig,

package/src/heartbeat/heartbeat-service.ts

@@ -46,7 +46,6 @@ const DEFAULT_CHECKLIST = `- Check in with yourself. Read NOW.md. Is it still ac
 
 const EARLY_HEARTBEAT_THRESHOLD = 3;
 const REENGAGEMENT_COOLDOWN_MS = 18 * 60 * 60 * 1000; // 18 hours
-const HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 
 // Stripped-comment form of the guardian persona scaffold. Computed
 // once at module load because stripping comment lines is deterministic
@@ -774,8 +773,8 @@ export class HeartbeatService {
     //
     // The runner fires `onConversationCreated` synchronously after
     // bootstrap so the macOS sidebar gets the new conversation
-    // immediately rather than waiting up to HEARTBEAT_TIMEOUT_MS for
-    // the LLM turn to finish. If the model judges the run worth
+    // immediately rather than waiting up to the full background-turn timeout
+    // for the LLM turn to finish. If the model judges the run worth
     // surfacing to the guardian, it calls the `notifications` skill
     // directly — no in-band marker.
     let conversationId: string | undefined;
@@ -789,7 +788,7 @@ export class HeartbeatService {
         trustClass: "guardian",
       },
       callSite: "heartbeatAgent",
-      timeoutMs: HEARTBEAT_TIMEOUT_MS,
+      timeoutMs: getConfig().timeouts.backgroundTurnTimeoutSec * 1000,
       origin: "heartbeat",
       deferNotifications: true,
       onConversationCreated: (newConversationId) => {

package/src/ipc/__tests__/attachment-ipc.test.ts

@@ -20,7 +20,7 @@ import { cliIpcCall } from "../cli-client.js";
 // DB setup (attachment store needs SQLite)
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -24,12 +24,14 @@ let mockOperationCalls: Array<{
   conversationId: string;
   trustClass?: string;
   transportInterface?: string;
+  sourceActorPrincipalId?: string;
 }> = [];
 
 /** When set, findConversation returns a fake conversation object. */
 let mockConversation: {
   trustContext?: { trustClass: string };
   transportInterface?: string;
+  getTurnActorPrincipalId?: () => string | undefined;
 } | null = null;
 
 let mockFindConversationCalls: string[] = [];
@@ -42,6 +44,7 @@ mock.module("../../browser/operations.js", () => ({
       conversationId: string;
       trustClass?: string;
       transportInterface?: string;
+      sourceActorPrincipalId?: string;
     },
   ) => {
     mockOperationCalls.push({
@@ -50,6 +53,7 @@ mock.module("../../browser/operations.js", () => ({
       conversationId: context.conversationId,
       trustClass: context.trustClass,
       transportInterface: context.transportInterface,
+      sourceActorPrincipalId: context.sourceActorPrincipalId,
     });
     return mockOperationResult;
   },
@@ -71,8 +75,16 @@ const browserExecuteHandler = ROUTES.find(
 )!.handler;
 
 /** Call the handler with the RouteHandlerArgs shape. */
-function callHandler(body: Record<string, unknown>) {
-  return browserExecuteHandler({ body, pathParams: {}, queryParams: {} });
+function callHandler(
+  body: Record<string, unknown>,
+  headers?: Record<string, string>,
+) {
+  return browserExecuteHandler({
+    body,
+    headers,
+    pathParams: {},
+    queryParams: {},
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -187,6 +199,7 @@ describe("browser_execute route", () => {
     mockConversation = {
       trustContext: { trustClass: "trusted" },
       transportInterface: "chrome-extension",
+      getTurnActorPrincipalId: () => undefined,
     };
 
     await callHandler({
@@ -204,6 +217,64 @@ describe("browser_execute route", () => {
     });
   });
 
+  test("threads actor principal header into browser tool context", async () => {
+    await callHandler(
+      {
+        operation: "status",
+        input: {},
+        sessionId: "actor-session",
+      },
+      { "x-vellum-actor-principal-id": "actor-123" },
+    );
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0].sourceActorPrincipalId).toBe("actor-123");
+  });
+
+  test("falls back to live conversation actor when no actor header exists", async () => {
+    mockConversation = {
+      trustContext: { trustClass: "trusted" },
+      transportInterface: "macos",
+      getTurnActorPrincipalId: () => "conversation-actor",
+    };
+
+    await callHandler({
+      operation: "status",
+      input: {},
+      sessionId: "unused",
+      conversationId: "conv-live-actor",
+    });
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0]).toMatchObject({
+      conversationId: "conv-live-actor",
+      sourceActorPrincipalId: "conversation-actor",
+    });
+  });
+
+  test("prefers live conversation actor over the request header", async () => {
+    mockConversation = {
+      trustContext: { trustClass: "trusted" },
+      transportInterface: "macos",
+      getTurnActorPrincipalId: () => "conversation-actor",
+    };
+
+    await callHandler(
+      {
+        operation: "status",
+        input: {},
+        sessionId: "unused",
+        conversationId: "conv-live-actor",
+      },
+      { "x-vellum-actor-principal-id": "header-actor" },
+    );
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0].sourceActorPrincipalId).toBe(
+      "conversation-actor",
+    );
+  });
+
   test("does not call findConversation when no conversationId provided", async () => {
     await callHandler({
       operation: "snapshot",

package/src/ipc/__tests__/clients-list-ipc.test.ts

@@ -36,7 +36,7 @@ mock.module("../../config/env.js", () => ({
 }));
 
 mock.module("../../runtime/local-actor-identity.js", () => ({
-  findLocalGuardianPrincipalId: () => fakeLocalPrincipalId,
+  findLocalGuardianPrincipalIdFromStore: () => fakeLocalPrincipalId,
 }));
 
 // ── Real imports (after mocks) ────────────────────────────────────────────