@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/runtime/access-request-helper.ts

@@ -1,29 +1,30 @@
 /**
  * Shared access-request creation and notification helper.
  *
- * Encapsulates the "create/dedupe canonical access request + emit notification"
+ * Encapsulates the "create/dedupe guardian access request + emit notification"
  * logic so both text-channel and voice-channel ingress paths use identical
  * guardian notification flows.
  *
- * Access requests are a special case: they always create a canonical request
+ * Access requests are a special case: they always create a guardian request
  * and emit a notification signal, even when no same-channel guardian binding
  * exists. Guardian identity resolution is anchored on the assistant's vellum
  * principal so access requests cannot bind to stale/cross-assistant contacts.
  */
 
-import type { ChannelId } from "../channels/types.js";
 import {
-  createCanonicalGuardianRequest,
-  listCanonicalGuardianRequests,
-} from "../contacts/canonical-guardian-store.js";
+  createGuardianRequest,
+  listGuardianRequestsOrEmpty,
+} from "../channels/gateway-guardian-requests.js";
+import type { ChannelId } from "../channels/types.js";
 import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
 import type { ChannelStatus } from "../contacts/types.js";
+import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import {
   recordApprovalCardDelivery,
   recordGuardianRequestDeliveries,
-} from "../notifications/canonical-delivery-recorder.js";
-import { emitNotificationSignal } from "../notifications/emit-signal.js";
+} from "../notifications/guardian-delivery-recorder.js";
 import type { GuardianResolutionSource } from "../notifications/signal.js";
+import { IntegrityError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { resolveAnchoredGuardian } from "./anchored-guardian.js";
 import { CHALLENGE_TTL_MS } from "./channel-verification-service.js";
@@ -96,28 +97,31 @@ export function accessRequestConversationId(
  * Whether the guardian has already terminally denied an access request from
  * this actor on this channel. Callers use it to suppress re-engagement — both
  * the guardian prompt and the self-verify challenge — for a sender the guardian
- * explicitly rejected. Reads the retained `denied` canonical request scoped by
+ * explicitly rejected. Reads the retained `denied` guardian request scoped by
  * the assistant-scoped conversation id.
+ *
+ * Gateway-unreachable degrades to `false` (no suppression data): callers then
+ * proceed toward creation, where the fail-closed create throw is the backstop
+ * against prompting without a persisted request.
  */
-export function isAccessRequestDenied(params: {
+export async function isAccessRequestDenied(params: {
   canonicalAssistantId: string;
   sourceChannel: string;
   actorExternalId: string;
-}): boolean {
+}): Promise<boolean> {
   const conversationId = accessRequestConversationId(
     params.canonicalAssistantId,
     params.sourceChannel,
     params.actorExternalId,
   );
-  return (
-    listCanonicalGuardianRequests({
-      status: "denied",
-      requesterExternalUserId: params.actorExternalId,
-      sourceChannel: params.sourceChannel,
-      kind: "access_request",
-      conversationId,
-    }).length > 0
-  );
+  const denied = await listGuardianRequestsOrEmpty({
+    status: "denied",
+    requesterExternalUserId: params.actorExternalId,
+    sourceChannel: params.sourceChannel,
+    kind: "access_request",
+    sourceConversationId: conversationId,
+  });
+  return denied.length > 0;
 }
 
 /**
@@ -136,12 +140,16 @@ export function isAccessRequestDenied(params: {
  *
  * Voice is excluded: phone approvals activate the caller directly and never
  * mint a code.
+ *
+ * Gateway-unreachable degrades to `false` (window unknown → treat as closed);
+ * the worst case is a redundant re-prompt attempt whose create is itself
+ * fail-closed.
  */
-export function isApprovalHandshakeInProgress(params: {
+export async function isApprovalHandshakeInProgress(params: {
   canonicalAssistantId: string;
   sourceChannel: string;
   actorExternalId: string;
-}): boolean {
+}): Promise<boolean> {
   if (params.sourceChannel === "phone") {
     return false;
   }
@@ -151,13 +159,14 @@ export function isApprovalHandshakeInProgress(params: {
     params.actorExternalId,
   );
   const windowStart = Date.now() - CHALLENGE_TTL_MS;
-  return listCanonicalGuardianRequests({
+  const approved = await listGuardianRequestsOrEmpty({
     status: "approved",
     requesterExternalUserId: params.actorExternalId,
     sourceChannel: params.sourceChannel,
     kind: "access_request",
-    conversationId,
-  }).some((request) => request.updatedAt >= windowStart);
+    sourceConversationId: conversationId,
+  });
+  return approved.some((request) => request.updatedAt >= windowStart);
 }
 
 // ---------------------------------------------------------------------------
@@ -165,7 +174,7 @@ export function isApprovalHandshakeInProgress(params: {
 // ---------------------------------------------------------------------------
 
 /**
- * Create/dedupe a canonical access request and emit a notification signal
+ * Create/dedupe a guardian access request and emit a notification signal
  * so the guardian can approve or deny the unknown sender.
  *
  * Returns a result indicating whether the guardian was notified and whether
@@ -175,7 +184,7 @@ export function isApprovalHandshakeInProgress(params: {
  * trust anchor and only accepts source-channel contacts that match it. This
  * prevents stale or cross-assistant contacts from being bound to the request.
  *
- * The canonical store writes complete before this resolves; the notification
+ * The gateway guardian-request writes complete before this resolves; the notification
  * signal emission is fire-and-forget.
  */
 export async function notifyGuardianOfAccessRequest(
@@ -234,26 +243,27 @@ export async function notifyGuardianOfAccessRequest(
     actorExternalId,
   );
 
-  // Deduplicate: skip creation if there is already a pending canonical request
+  // Deduplicate: skip creation if there is already a pending guardian request
   // for the same requester on this channel *and* assistant. Still return
   // notified: true with the existing request ID so callers know the guardian
-  // was already notified.
-  const existingCanonical = listCanonicalGuardianRequests({
+  // was already notified. A degraded (empty) read falls through to creation,
+  // whose fail-closed throw prevents a prompt without a persisted request.
+  const existingPending = await listGuardianRequestsOrEmpty({
     status: "pending",
     requesterExternalUserId: actorExternalId,
     sourceChannel,
     kind: "access_request",
-    conversationId,
+    sourceConversationId: conversationId,
   });
-  if (existingCanonical.length > 0) {
+  if (existingPending.length > 0) {
     log.debug(
-      { sourceChannel, actorExternalId, existingId: existingCanonical[0].id },
+      { sourceChannel, actorExternalId, existingId: existingPending[0].id },
       "Skipping duplicate access request notification",
     );
     return {
       notified: true,
       created: false,
-      requestId: existingCanonical[0].id,
+      requestId: existingPending[0].id,
     };
   }
 
@@ -266,7 +276,7 @@ export async function notifyGuardianOfAccessRequest(
   // handshake window below so a standing deny always wins over an earlier
   // approval.
   if (
-    isAccessRequestDenied({
+    await isAccessRequestDenied({
       canonicalAssistantId,
       sourceChannel,
       actorExternalId,
@@ -285,7 +295,7 @@ export async function notifyGuardianOfAccessRequest(
   // request or re-notify the guardian; once the window lapses unconsumed,
   // re-prompting is allowed again.
   if (
-    isApprovalHandshakeInProgress({
+    await isApprovalHandshakeInProgress({
       canonicalAssistantId,
       sourceChannel,
       actorExternalId,
@@ -301,16 +311,23 @@ export async function notifyGuardianOfAccessRequest(
   const senderIdentifier = actorDisplayName || actorUsername || actorExternalId;
   const requestId = `access-req-${canonicalAssistantId}-${sourceChannel}-${actorExternalId}-${Date.now()}`;
 
-  const canonicalRequest = createCanonicalGuardianRequest({
+  // Access requests are decisionable: without a bound principal nobody could
+  // ever decide them (mirrors the gateway create's integrity guard).
+  if (!guardianPrincipalId) {
+    throw new IntegrityError(
+      "Cannot create access_request without guardianPrincipalId",
+    );
+  }
+
+  const guardianRequest = await createGuardianRequest({
     id: requestId,
     kind: "access_request",
-    sourceType: "channel",
     sourceChannel,
-    conversationId,
+    sourceConversationId: conversationId,
     requesterExternalUserId: actorExternalId,
     requesterChatId: conversationExternalId,
     guardianExternalUserId: guardianExternalUserId ?? undefined,
-    guardianPrincipalId: guardianPrincipalId ?? undefined,
+    guardianPrincipalId,
     toolName: "ingress_access_request",
     questionText: introductionMode(trigger).questionText(senderIdentifier),
     requesterSignals: serializeRequesterSignals({
@@ -320,11 +337,11 @@ export async function notifyGuardianOfAccessRequest(
     }),
     // Persisted so decision-time policy (resolvers, expiry sweep) can
     // suppress requester-facing lifecycle notices for admitted-mode nudges.
-    ...(trigger === "admitted" ? { trigger } : {}),
+    ...(trigger === "admitted" ? { requestTrigger: trigger } : {}),
     expiresAt: Date.now() + GUARDIAN_APPROVAL_TTL_MS,
   });
 
-  let vellumDeliveryId: string | undefined;
+  let vellumDeliveryIdPromise: Promise<string | undefined> | undefined;
   // When the access request originates from a text channel with
   // notification delivery support (Slack, Telegram) and the guardian was
   // resolved via a verified same-channel contact, route the notification
@@ -357,7 +374,7 @@ export async function notifyGuardianOfAccessRequest(
     },
     contextPayload: {
       requestId,
-      requestCode: canonicalRequest.requestCode ?? "",
+      requestCode: guardianRequest.requestCode ?? "",
       sourceChannel,
       conversationExternalId,
       actorExternalId,
@@ -374,43 +391,47 @@ export async function notifyGuardianOfAccessRequest(
       ...(messageTs ? { messageTs } : {}),
       ...(trigger === "admitted" ? { trigger } : {}),
     },
-    dedupeKey: `access-request:${canonicalRequest.id}`,
+    dedupeKey: `access-request:${guardianRequest.id}`,
+    // The returned promise is awaited by the broadcaster before the client
+    // can learn of the conversation, so the delivery row exists before the
+    // in-app card is actionable; the post-broadcast loop reuses its row id.
     onConversationCreated: (info) => {
       if (
         info.sourceEventName !== "ingress.access_request" ||
-        vellumDeliveryId
+        vellumDeliveryIdPromise
       ) {
         return;
       }
-      vellumDeliveryId = recordApprovalCardDelivery({
-        requestId: canonicalRequest.id,
+      vellumDeliveryIdPromise = recordApprovalCardDelivery({
+        requestId: guardianRequest.id,
         channel: "vellum",
         conversationId: info.conversationId,
-      })?.id;
+      }).then((delivery) => delivery?.id);
+      return vellumDeliveryIdPromise.then(() => undefined);
     },
   })
-    .then((signalResult) => {
-      vellumDeliveryId = recordGuardianRequestDeliveries({
-        requestId: canonicalRequest.id,
+    .then(async (signalResult) => {
+      const vellumDeliveryId = await recordGuardianRequestDeliveries({
+        requestId: guardianRequest.id,
         deliveryResults: signalResult.deliveryResults,
-        vellumDeliveryId,
+        vellumDeliveryId: await vellumDeliveryIdPromise,
       });
 
       if (!vellumDeliveryId && !sameChannelOnly) {
-        recordApprovalCardDelivery({
-          requestId: canonicalRequest.id,
+        await recordApprovalCardDelivery({
+          requestId: guardianRequest.id,
           channel: "vellum",
           status: "failed",
         });
         log.warn(
-          { requestId: canonicalRequest.id, reason: signalResult.reason },
+          { requestId: guardianRequest.id, reason: signalResult.reason },
           "Notification pipeline did not produce a vellum delivery result for access request",
         );
       }
     })
     .catch((err) => {
       log.error(
-        { err, requestId: canonicalRequest.id, sourceChannel, actorExternalId },
+        { err, requestId: guardianRequest.id, sourceChannel, actorExternalId },
         "Failed to persist access request delivery rows from notification pipeline",
       );
     });
@@ -426,7 +447,7 @@ export async function notifyGuardianOfAccessRequest(
     "Guardian notified of access request",
   );
 
-  return { notified: true, created: true, requestId: canonicalRequest.id };
+  return { notified: true, created: true, requestId: guardianRequest.id };
 }
 
 /**
@@ -461,12 +482,15 @@ export async function maybeNotifyGuardianOfAdmittedContact(
     params.sourceChannel,
     params.actorExternalId,
   );
-  const alreadyIntroducedHere = listCanonicalGuardianRequests({
+  // Degraded (empty) read lets the nudge proceed; the inner suppressions and
+  // the fail-closed create still bound it to at most one live card.
+  const priorRequests = await listGuardianRequestsOrEmpty({
     kind: "access_request",
     requesterExternalUserId: params.actorExternalId,
     sourceChannel: params.sourceChannel,
-    conversationId,
-  }).some(
+    sourceConversationId: conversationId,
+  });
+  const alreadyIntroducedHere = priorRequests.some(
     (request) => request.requesterChatId === params.conversationExternalId,
   );
   if (alreadyIntroducedHere) {

package/src/runtime/actor-trust-resolver.ts

@@ -241,7 +241,7 @@ export function toTrustContext(
   ctx: ActorTrustContext,
   conversationExternalId: string,
 ): TrustContext {
-  const canonicalGuardianExternalUserId = ctx.guardianBindingMatch
+  const normalizedGuardianExternalUserId = ctx.guardianBindingMatch
     ?.guardianExternalUserId
     ? (canonicalizeInboundIdentity(
         ctx.actorMetadata.channel,
@@ -254,7 +254,7 @@ export function toTrustContext(
     guardianChatId:
       ctx.guardianBindingMatch?.guardianDeliveryChatId ??
       (ctx.trustClass === "guardian" ? conversationExternalId : undefined),
-    guardianExternalUserId: canonicalGuardianExternalUserId,
+    guardianExternalUserId: normalizedGuardianExternalUserId,
     guardianPrincipalId: ctx.guardianPrincipalId,
     requesterIdentifier: ctx.actorMetadata.identifier,
     requesterDisplayName: ctx.actorMetadata.displayName,

package/src/runtime/agent-wake.ts

@@ -37,6 +37,11 @@
  *   - Tool calls produced → normal tool execution runs (the conversation's
  *     `AgentLoop` has its tool executor already wired). Returns
  *     `{ invoked: true, producedToolCalls: true }`.
+ *   - Loop threw before ANY output went live or was persisted → the wake did
+ *     no work. Returns `{ invoked: false, reason: "run_error" }` so callers
+ *     that advance state on success (memory retrospective watermark,
+ *     scheduler feed events) can retry instead of recording a phantom pass.
+ *     A throw after output went live still returns `invoked: true`.
  *
  * Concurrency:
  *   - If a user turn (or another wake) is currently in flight on the same
@@ -65,8 +70,6 @@ import type {
 import type { InterfaceId } from "../channels/types.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import {
-  isOverrideOrDefaultResolutionEnabled,
-  resolveDefaultProfileKey,
   resolveProfilelessModelKey,
   selectWinningProfile,
 } from "../config/llm-resolver.js";
@@ -369,7 +372,18 @@ export type WakeSkipReason =
    * run cannot proceed without the compaction it was told not to perform.
    * Only possible on suppressed wakes.
    */
-  | "context_overflow";
+  | "context_overflow"
+  /**
+   * The agent loop threw before producing ANY output — no checkpoint fired
+   * and no tail message was emitted or persisted (typically a provider
+   * failure on the run's first LLM call). The wake did no work, so callers
+   * that treat `invoked: true` as "the pass ran" (e.g. the memory
+   * retrospective, which advances its processed-message watermark and
+   * finalizes on success) must see a retryable failure rather than a
+   * silent no-op. A throw AFTER output went live keeps `invoked: true` —
+   * side effects have already landed and the run must not read as skipped.
+   */
+  | "run_error";
 
 export interface WakeResult {
   invoked: boolean;
@@ -423,7 +437,9 @@ async function defaultResolveTarget(
     await import("../daemon/conversation-store.js");
   try {
     const existing = getConversation(conversationId);
-    if (!existing) return null;
+    if (!existing) {
+      return null;
+    }
     if (existing.archivedAt != null) {
       log.info(
         { conversationId },
@@ -573,7 +589,9 @@ function inspectWakeOutput(
   let hasVisibleText = false;
   const toolUseNames: string[] = [];
   for (const msg of tailMessages) {
-    if (msg.role !== "assistant") continue;
+    if (msg.role !== "assistant") {
+      continue;
+    }
     const blocks = Array.isArray(msg.content) ? msg.content : [];
     for (const block of blocks) {
       if (block.type === "text" && typeof block.text === "string") {
@@ -733,21 +751,14 @@ export async function wakeAgentForOpportunity(
       overrideProfile,
       forceOverrideProfile,
     });
-    // Same winner-selection sourcing as the agent loop's key: under
-    // override-or-default semantics a hand-mirrored chain would disagree
-    // with dispatch (a non-forced override now wins on every call site).
+    // Same winner-selection sourcing as the agent loop's key: a hand-mirrored
+    // chain would disagree with dispatch (a non-forced override wins on every
+    // call site).
     const modelProfileKey =
-      (isOverrideOrDefaultResolutionEnabled()
-        ? selectWinningProfile(callSite, config.llm, {
-            ...(overrideProfile != null ? { overrideProfile } : {}),
-            selectionSeed: conversationId,
-          }).profileName
-        : ((forceOverrideProfile || callSite === "mainAgent"
-            ? overrideProfile
-            : undefined) ??
-          resolveDefaultProfileKey(callSite, config.llm) ??
-          overrideProfile ??
-          resolveDefaultProfileKey("mainAgent", config.llm))) ??
+      selectWinningProfile(callSite, config.llm, {
+        ...(overrideProfile != null ? { overrideProfile } : {}),
+        selectionSeed: conversationId,
+      }).profileName ??
       resolveProfilelessModelKey(callSite, config.llm, {
         ...(overrideProfile != null ? { overrideProfile } : {}),
         ...(forceOverrideProfile ? { forceOverrideProfile: true } : {}),
@@ -1107,7 +1118,9 @@ export async function wakeAgentForOpportunity(
     // and renames `text_delta` → `assistant_text_delta`; bypassing it
     // would ship malformed wire frames.
     const goLive = (currentHistory: Message[]): void => {
-      if (mode === "live") return;
+      if (mode === "live") {
+        return;
+      }
       if (!surfaceInjected) {
         if (!opts.suppressWakeSurface) {
           const tailStart = baselineLength + wakeHintMessageCount;
@@ -1170,7 +1183,9 @@ export async function wakeAgentForOpportunity(
       currentHistory: Message[],
     ): Promise<void> => {
       const start = baselineLength + wakeHintMessageCount + persistedTailIndex;
-      if (start >= currentHistory.length) return;
+      if (start >= currentHistory.length) {
+        return;
+      }
       const newMessages = currentHistory.slice(start);
       for (const msg of newMessages) {
         conversation.messages.push(msg);
@@ -1191,9 +1206,13 @@ export async function wakeAgentForOpportunity(
     let wakeToolScopeRestored = false;
     let restoreWakeToolScope: (() => void) | null = null;
     const restoreWakeAllowedTools = (): void => {
-      if (wakeToolScopeRestored) return;
+      if (wakeToolScopeRestored) {
+        return;
+      }
       wakeToolScopeRestored = true;
-      if (!restoreWakeToolScope) return;
+      if (!restoreWakeToolScope) {
+        return;
+      }
       try {
         restoreWakeToolScope();
       } catch (err) {
@@ -1204,7 +1223,9 @@ export async function wakeAgentForOpportunity(
       }
     };
     const applyWakeAllowedTools = (): boolean => {
-      if (!opts.allowedTools) return true;
+      if (!opts.allowedTools) {
+        return true;
+      }
       try {
         restoreWakeToolScope = scopeWakeAllowedTools(
           conversation,
@@ -1245,6 +1266,11 @@ export async function wakeAgentForOpportunity(
     // block skips its generic outcome log for this path — the failure
     // already logged its own dedicated warn line.
     let failedContextOverflow = false;
+    // Set when a mid-run throw was reported as `invoked: false` (reason
+    // "run_error") because nothing had gone live or been persisted. The
+    // finally's error log names the reported outcome so the line matches
+    // what the caller actually saw.
+    let reportedRunErrorAsFailure = false;
     // Shared failure path for an over-window condition on a
     // compaction-suppressed wake (reached from the pre-flight estimate, from
     // the run's catch when the rejection escaped as a throw, or post-run when
@@ -1321,7 +1347,9 @@ export async function wakeAgentForOpportunity(
       const priorTurnTrust = conversation.currentTurnTrustContext;
       conversation.currentCallSite = callSite;
       conversation.currentTurnOverrideProfile = overrideProfile;
-      if (opts.clientless) conversation.hasNoClient = true;
+      if (opts.clientless) {
+        conversation.hasNoClient = true;
+      }
       // Per-turn guardian elevation for the wake's tools, set after the pre-run
       // reads so a pre-run failure can't leak it; restored in the finally.
       if (opts.trustContext) {
@@ -1381,6 +1409,25 @@ export async function wakeAgentForOpportunity(
         // run threw mid-flight. The outer finally still runs to release
         // `processing` and drain the queue.
         runError = err instanceof Error ? err : new Error(String(err));
+        // Nothing went live and nothing was persisted: no checkpoint fired
+        // (mode never left "buffering") and no tail message was flushed.
+        // The run died before doing any work — typically a provider error
+        // on the first LLM call — so report a failure instead of a silent
+        // no-op. Callers gate real state transitions on `invoked` (the
+        // memory retrospective advances its processed-message watermark
+        // and finalizes on success; the scheduler emits a success feed
+        // event), and a no-op result here permanently consumes their
+        // trigger without a run ever happening. A throw after output went
+        // live keeps `invoked: true`: side effects have already landed,
+        // and the run must not read as skipped.
+        if (mode === "buffering" && persistedTailIndex === 0) {
+          reportedRunErrorAsFailure = true;
+          return {
+            invoked: false,
+            producedToolCalls: false,
+            reason: "run_error" as const,
+          };
+        }
         return { invoked: true, producedToolCalls: false };
       } finally {
         // Restore the pre-wake values so a queued user turn or background read
@@ -1515,7 +1562,9 @@ export async function wakeAgentForOpportunity(
             hintRole,
             err: runError,
           },
-          "agent-wake: agent loop threw; treating as no-op",
+          reportedRunErrorAsFailure
+            ? "agent-wake: agent loop threw before producing output; reported as run_error"
+            : "agent-wake: agent loop threw after output went live; treating as no-op",
         );
       } else if (tailMessageCount === 0) {
         log.info(

package/src/runtime/assistant-event-hub.ts

@@ -26,6 +26,7 @@ const HOST_PREFIX_TO_CAPABILITY: Record<string, HostProxyCapability> = {
   host_cu: "host_cu",
   host_browser: "host_browser",
   host_app_control: "host_app_control",
+  host_ui_snapshot: "host_ui_snapshot",
 };
 
 /**

package/src/runtime/auth/__tests__/middleware.test.ts

@@ -18,13 +18,6 @@ const testDir = realpathSync(
   mkdtempSync(join(tmpdir(), "auth-middleware-test-")),
 );
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Track auth bypass state for tests
 let authDisabled = false;
 mock.module("../../../config/env.js", () => ({
@@ -34,9 +27,7 @@ mock.module("../../../config/env.js", () => ({
 }));
 
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
-import {
-  authenticateRequest,
-} from "../middleware.js";
+import { authenticateRequest } from "../middleware.js";
 import { initAuthSigningKey, mintToken } from "../token-service.js";
 import type { ScopeProfile, TokenAudience } from "../types.js";
 

package/src/runtime/auth/__tests__/route-policy.test.ts

@@ -20,13 +20,6 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Track auth bypass state for tests
 let authDisabled = false;
 mock.module("../../../config/env.js", () => ({

package/src/runtime/auth/__tests__/token-service.test.ts

@@ -1,11 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { CURRENT_POLICY_EPOCH } from "../policy.js";
 import {

package/src/runtime/auth/same-actor.ts

@@ -47,7 +47,8 @@ export type SameActorOp =
   | "host_cu"
   | "host_browser"
   | "host_app_control"
-  | "host_transfer";
+  | "host_transfer"
+  | "host_ui_snapshot";
 
 /**
  * Args for the live-lookup variant: caller supplies the hub + target client

package/src/runtime/background-job-runner.ts

@@ -193,6 +193,14 @@ export interface RunBackgroundJobOptions {
    * run completes successfully. See `notifications/deferred-emit.ts`.
    */
   deferNotifications?: boolean;
+  /**
+   * Persist the kickoff `prompt` without indexing it — no memory segments,
+   * no embeddings, no lexical-index entry. Opt-in for jobs whose prompt is a
+   * static machine-authored instruction manual (e.g. memory consolidation)
+   * that must not enter memory or search on every run. The run's replies and
+   * all other messages index normally. Defaults to false.
+   */
+  skipPromptIndexing?: boolean;
 }
 
 export interface RunBackgroundJobResult {
@@ -200,6 +208,14 @@ export interface RunBackgroundJobResult {
   ok: boolean;
   error?: Error;
   errorKind?: BackgroundJobErrorKind;
+  /**
+   * Stable classified error code (`ConversationErrorCode`, e.g.
+   * `"PROVIDER_BILLING"`) when the turn failed without throwing. Absent for
+   * timeouts and thrown exceptions. Lets callers branch on the failure class
+   * (e.g. billing vs transient) without depending on error identity or
+   * message text.
+   */
+  failureCode?: string;
   /**
    * Set when the runner declined to execute. Callers can distinguish a
    * skipped job from a successful one even though both report `ok: true`.
@@ -341,6 +357,7 @@ export async function runBackgroundJob(
       ...(opts.cronRunId ? { cronRunId: opts.cronRunId } : {}),
       ...(opts.allowedTools ? { allowedTools: opts.allowedTools } : {}),
       ...(opts.toolGateMode ? { toolGateMode: opts.toolGateMode } : {}),
+      ...(opts.skipPromptIndexing ? { skipUserMessageIndexing: true } : {}),
     });
     // Absorb late rejections: if the timeout wins the race, `work` keeps
     // running and may eventually reject — swallow so it doesn't surface as
@@ -380,6 +397,10 @@ export async function runBackgroundJob(
   } catch (err) {
     const errorKind = classifyError(err);
     const error = err instanceof Error ? err : new Error(String(err));
+    const failureCode =
+      err instanceof BackgroundJobTurnFailureError
+        ? err.failureCode
+        : undefined;
     // Bootstrap can fail before `conversation` is assigned; fall back to ""
     // so the structured failure result still flows to the caller.
     const conversationId = conversation?.id ?? "";
@@ -439,6 +460,7 @@ export async function runBackgroundJob(
       ok: false,
       error,
       errorKind,
+      ...(failureCode !== undefined ? { failureCode } : {}),
     };
   } finally {
     if (timer) clearTimeout(timer);