@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/daemon/handlers/conversations.ts

@@ -1,10 +1,12 @@
 import { v4 as uuid } from "uuid";
 
 import { peekAcpSessionManager } from "../../acp/index.js";
+import { resolveCanonicalGuardianRequest } from "../../memory/canonical-guardian-store.js";
 import { clearAll, getConversation } from "../../memory/conversation-crud.js";
 import { resolveConversationId } from "../../memory/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import { resolveCapabilities } from "../../runtime/capabilities.js";
+import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { UserError } from "../../util/errors.js";
@@ -389,6 +391,81 @@ export function steerToMessage(
   return { steered: true };
 }
 
+/**
+ * Supersede an open `ask_question` prompt when a new chat message is enqueued
+ * for the same conversation.
+ *
+ * A queued message while a clarification question is open means the user chose
+ * to move on rather than answer it. Steering to that message aborts the parked
+ * turn — which settles the open question via its turn-abort signal — repairs
+ * the dangling `tool_use`, and drains the message, instead of stranding it
+ * behind a prompt no one is going to answer. Only `ask_question` prompts
+ * (`kind: "question"`) trigger this; pending confirmations are handled
+ * separately by the enqueue path's auto-deny.
+ *
+ * Returns `true` when a parked question was found and a steer was issued.
+ */
+export function steerOnEnqueuedMessageIfQuestionParked(
+  conversationId: string,
+  enqueuedRequestId: string,
+): boolean {
+  const hasParkedQuestion = pendingInteractions
+    .getByConversation(conversationId)
+    .some((interaction) => interaction.kind === "question");
+  if (!hasParkedQuestion) return false;
+  steerToMessage(conversationId, enqueuedRequestId);
+  return true;
+}
+
+/**
+ * Supersede interactions left pending by an in-flight turn when a new message
+ * is enqueued for a busy conversation. Centralized so every ingress path (the
+ * HTTP send handler and the CLI signal path) gets identical handling:
+ *
+ *  1. Auto-deny pending confirmations — notify the client and sync the
+ *     canonical guardian record *before* clearing the prompter-owned
+ *     confirmations, so a later guardian reply can't match a stale "pending"
+ *     record and fail with `pending_interaction_not_found`.
+ *  2. Supersede a parked ask_question by steering to the enqueued message.
+ *
+ * Order matters: the steer aborts the turn, which denies the prompter's
+ * confirmations as a side effect, so the canonical/notification sync must run
+ * first. `removeByConversation` preserves `question` entries, so the parked
+ * question is still registered for the steer even after the confirmation sweep.
+ */
+export function supersedePendingInteractionsOnEnqueue(
+  conversationId: string,
+  enqueuedRequestId: string,
+): void {
+  const conversation = findConversation(conversationId);
+  if (!conversation) return;
+
+  if (conversation.hasAnyPendingConfirmation()) {
+    for (const interaction of pendingInteractions.getByConversation(
+      conversationId,
+    )) {
+      if (interaction.kind === "confirmation") {
+        // sendToClient (wired to the SSE hub) delivers the denial to clients.
+        conversation.emitConfirmationStateChanged({
+          conversationId,
+          requestId: interaction.requestId,
+          state: "denied" as const,
+          source: "auto_deny" as const,
+        });
+        // Sync the canonical guardian record so stale "pending" rows aren't
+        // matched by later guardian reply routing.
+        resolveCanonicalGuardianRequest(interaction.requestId, "pending", {
+          status: "denied",
+        });
+      }
+    }
+    conversation.denyAllPendingConfirmations();
+    pendingInteractions.removeByConversation(conversationId);
+  }
+
+  steerOnEnqueuedMessageIfQuestionParked(conversationId, enqueuedRequestId);
+}
+
 // ---------------------------------------------------------------------------
 // HTTP handler (delegates to shared logic)
 // ---------------------------------------------------------------------------

package/src/daemon/host-cu-proxy.ts

@@ -44,6 +44,56 @@ const MAX_HISTORY_ENTRIES = 10;
 const LOOP_DETECTION_WINDOW = 3;
 const CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD = 2;
 
+// computer_use_key combos that change only selection/cursor/clipboard state.
+// The AX tree models none of these, so they always produce an empty diff —
+// exempt them from the "NO VISIBLE EFFECT" signal (mirrors computer_use_wait).
+// Stored in canonical form (see canonicalizeKeyCombo): modifier aliases
+// normalized and ordered, so `cmd + a`, `command+a`, `alt+tab`, `tab+shift`
+// all match.
+const NO_AX_DIFF_KEY_COMBOS = new Set([
+  "cmd+a",
+  "cmd+c",
+  "up",
+  "down",
+  "left",
+  "right",
+  "shift+tab",
+  "option+tab",
+]);
+
+// Modifier aliases mirror the mac helper's ActionExecutor.pressKey so the
+// exemption check matches exactly what the helper will execute.
+const KEY_MODIFIER_ALIASES: Record<string, string> = {
+  cmd: "cmd",
+  command: "cmd",
+  option: "option",
+  alt: "option",
+  ctrl: "ctrl",
+  control: "ctrl",
+  shift: "shift",
+};
+const KEY_MODIFIER_ORDER = ["cmd", "ctrl", "option", "shift"];
+
+/**
+ * Normalize a key combo the way the mac helper does (lowercase, split on `+`,
+ * trim, alias modifiers) into a canonical `mods…+base` string with modifiers
+ * in a fixed order — so order/alias/whitespace variants compare equal.
+ */
+function canonicalizeKeyCombo(key: string): string {
+  const mods = new Set<string>();
+  let base = "";
+  for (const raw of key.toLowerCase().split("+")) {
+    const part = raw.trim();
+    if (part.length === 0) continue;
+    const mod = KEY_MODIFIER_ALIASES[part];
+    if (mod) mods.add(mod);
+    else base = part; // last non-modifier wins, matching the executor
+  }
+  return [...KEY_MODIFIER_ORDER.filter((m) => mods.has(m)), base]
+    .filter((s) => s.length > 0)
+    .join("+");
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -69,6 +119,43 @@ export interface ActionRecord {
   reasoning?: string;
 }
 
+/**
+ * True when `action` is a computer_use_key press whose key only mutates
+ * selection/cursor/clipboard state — changes the AX tree cannot represent, so
+ * an empty diff is expected rather than a sign the action did nothing.
+ */
+function isNoDiffKeyAction(action: ActionRecord | undefined): boolean {
+  if (action?.toolName !== "computer_use_key") return false;
+  const key = action.input.key;
+  return (
+    typeof key === "string" &&
+    NO_AX_DIFF_KEY_COMBOS.has(canonicalizeKeyCombo(key))
+  );
+}
+
+/**
+ * Canonical signature for loop detection. Key presses collapse equivalent
+ * spellings (`cmd+a`, `command+a`, `cmd + a`) of the same combo so a stuck
+ * session retrying it with alias/whitespace variants is still caught —
+ * important now that exempt keys no longer emit no-effect warnings. Only the
+ * `key` value is normalized; all other input fields (e.g. the routing
+ * `target_client_id`) are preserved, so the same combo sent to different
+ * desktop clients is not mistaken for a repeat.
+ */
+function actionSignature(record: ActionRecord): string {
+  if (
+    record.toolName === "computer_use_key" &&
+    typeof record.input.key === "string"
+  ) {
+    const normalizedInput = {
+      ...record.input,
+      key: canonicalizeKeyCombo(record.input.key),
+    };
+    return `computer_use_key:${JSON.stringify(normalizedInput)}`;
+  }
+  return `${record.toolName}:${JSON.stringify(record.input)}`;
+}
+
 // ---------------------------------------------------------------------------
 // HostCuProxy
 // ---------------------------------------------------------------------------
@@ -385,8 +472,9 @@ export class HostCuProxy {
           ? this._actionHistory[this._actionHistory.length - 1]
           : undefined;
       const isWaitAction = lastAction?.toolName === "computer_use_wait";
+      const isNoDiffKey = isNoDiffKeyAction(lastAction);
 
-      if (!isWaitAction) {
+      if (!isWaitAction && !isNoDiffKey) {
         if (
           this._consecutiveUnchangedSteps >=
           CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
@@ -405,10 +493,9 @@ export class HostCuProxy {
 
     if (this._actionHistory.length >= LOOP_DETECTION_WINDOW) {
       const recent = this._actionHistory.slice(-LOOP_DETECTION_WINDOW);
+      const firstSignature = actionSignature(recent[0]);
       const allIdentical = recent.every(
-        (r) =>
-          r.toolName === recent[0].toolName &&
-          JSON.stringify(r.input) === JSON.stringify(recent[0].input),
+        (r) => actionSignature(r) === firstSignature,
       );
       if (allIdentical) {
         parts.push(
@@ -505,14 +592,18 @@ export class HostCuProxy {
 
   private updateStateFromObservation(obs: CuObservationResult): void {
     if (this._stepCount > 0) {
-      if (
-        obs.axDiff == null &&
-        this._previousAXTree != null &&
-        obs.axTree != null
-      ) {
-        this._consecutiveUnchangedSteps++;
-      } else if (obs.axDiff != null) {
+      const lastAction =
+        this._actionHistory.length > 0
+          ? this._actionHistory[this._actionHistory.length - 1]
+          : undefined;
+      if (obs.axDiff != null || isNoDiffKeyAction(lastAction)) {
+        // A real diff, or an exempt key whose effect is invisible by design,
+        // breaks the no-effect streak — clear it rather than preserving a
+        // stale count so an intervening cmd+a can't bridge two no-op actions
+        // into a false "consecutive" escalation.
         this._consecutiveUnchangedSteps = 0;
+      } else if (this._previousAXTree != null && obs.axTree != null) {
+        this._consecutiveUnchangedSteps++;
       }
     }
 

package/src/daemon/lifecycle.ts

@@ -966,6 +966,10 @@ export async function runDaemon(): Promise<void> {
         }
       }
 
+      // `startMemoryJobsWorker` selects the worker implementation based on
+      // `memory.worker.enabled` (in-process vs. a separate OS process).
+      // Shutdown stops whichever worker is actually running — see
+      // shutdown-handlers.ts.
       log.info("Daemon startup: starting memory worker");
       bgRefs.memoryWorker = startMemoryJobsWorker();
 

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

@@ -59,6 +59,18 @@ function configWithV2(enabled: boolean): AssistantConfig {
   return { memory: { v2: { enabled } } } as unknown as AssistantConfig;
 }
 
+/** Poll until `m` has been called at least `n` times, or `timeoutMs` elapses. */
+async function waitForCalls(
+  m: { mock: { calls: unknown[] } },
+  n: number,
+  timeoutMs = 1000,
+): Promise<void> {
+  const start = Date.now();
+  while (m.mock.calls.length < n && Date.now() - start < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
 afterEach(() => {
   seedSkill.mockClear();
   seedCli.mockClear();
@@ -128,4 +140,64 @@ describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
 
     expect(seedCli).toHaveBeenCalledTimes(1);
   });
+
+  test("enqueues the v3 maintain pass even when one catalog reseed rejects", async () => {
+    proxyState.prereqs = true;
+    v3State.live = true;
+    seedSkill.mockImplementationOnce(async () => {
+      throw new Error('Embedding backend "gemini" is not configured');
+    });
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
+
+    // The CLI catalog seeded, so v3 must still rebuild its lanes — a single
+    // catalog failure cannot suppress the maintain pass.
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("enqueues the v3 maintain pass without blocking when a catalog reseed exceeds the timeout", async () => {
+    proxyState.prereqs = true;
+    v3State.live = true;
+    // Skill reseed never settles — mirrors the wedged getCatalog()/embed seen in
+    // the field. The CLI reseed completes normally.
+    seedSkill.mockImplementationOnce(() => new Promise<void>(() => {}));
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
+      reseedTimeoutMs: 20,
+    });
+
+    // An unbounded `Promise.all` barrier would hang here forever; the bounded
+    // barrier lets the CLI catalog's maintain pass enqueue regardless.
+    expect(seedCli).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
+  });
+
+  test("re-enqueues the v3 maintain pass when a straggler catalog finishes after the timeout", async () => {
+    proxyState.prereqs = true;
+    v3State.live = true;
+    let resolveSkill!: () => void;
+    seedSkill.mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSkill = resolve;
+        }),
+    );
+
+    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
+      reseedTimeoutMs: 10,
+    });
+
+    // Post-barrier enqueue fires once even though the skill catalog is still
+    // embedding.
+    expect(enqueueJob).toHaveBeenCalledTimes(1);
+
+    // The straggler lands; maintain re-enqueues so its late capability rows are
+    // reconciled without waiting out the 6h backstop.
+    resolveSkill();
+    await waitForCalls(enqueueJob, 2);
+    expect(enqueueJob).toHaveBeenCalledTimes(2);
+  });
 });

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/server.ts

@@ -48,7 +48,6 @@ import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
 import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
-import { WorkspaceToolsWatcher } from "./workspace-tools-watcher.js";
 
 const log = getLogger("server");
 
@@ -308,8 +307,6 @@ export class DaemonServer {
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
-    WorkspaceToolsWatcher.getInstance().start();
-
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       broadcastMessage({ type: "contacts_changed" });
@@ -324,7 +321,6 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
-    WorkspaceToolsWatcher.getInstance().stop();
     this.cliIpc.stop();
     this.skillIpc.stop();
     if (this.unsubscribeContactChange) {

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

@@ -124,4 +124,13 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    * return `undefined` for the in-flight (background) subagent.
    */
   currentTurnOverrideProfile?: string;
+  /**
+   * 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.
+   */
+  currentTurnIsNonInteractive?: boolean;
 }

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) ────────────────────────────────────────────

package/src/ipc/assistant-server.ts

@@ -33,7 +33,7 @@ import { createServer, type Server, type Socket } from "node:net";
 
 import { ensureSocketDir, SocketWatchdog } from "@vellumai/ipc-server-utils";
 
-import { findLocalGuardianPrincipalId } from "../runtime/local-actor-identity.js";
+import { findLocalGuardianPrincipalIdFromStore } from "../runtime/local-actor-identity.js";
 import { RouteError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/index.js";
 import type {
@@ -637,7 +637,7 @@ function injectLocalActorHeader(
   // that require the header will fail-closed on their own.
   let localActor: string | undefined;
   try {
-    localActor = findLocalGuardianPrincipalId();
+    localActor = findLocalGuardianPrincipalIdFromStore();
   } catch (err) {
     log.debug(
       { err },