@ixo/oracle-runtime-workers 0.38.0 → 0.39.0

package/src/core/tool-access.ts

@@ -6,13 +6,8 @@ import type {
   PluginTool,
 } from '../plugin-api/types';
 import type { CapabilityRequirement } from './manifest';
-import type {
-  RegisteredSubAgent,
-  SubAgentRegistry,
-  ToolRegistry,
-} from './registries';
+import type { RegisteredSubAgent } from './registries';
 import { computeSubAgentToolName } from './subagent-as-tool';
-import { NOOP_LOGGER } from './utils';
 
 /** `ctx.ucan.hasCapability` bound to the turn's delegation. */
 export type HasCapability = (resource: string, action: string) => boolean;
@@ -53,8 +48,8 @@ export interface TurnToolAccess<
   /**
    * Plugins that contributed tools or sub-agents of which none is left.
    * Treated like a plugin whose `requires` are unmet (left out of the
-   * prompt, refused by `load_capability`, never preloaded) except that they
-   * are hidden outright: `list_capabilities` does not list them.
+   * prompt, refused by `load_capability`, not offered to the router) except
+   * that they are hidden outright: `list_capabilities` does not list them.
    */
   hiddenPlugins: ReadonlySet<string>;
 }
@@ -145,30 +140,6 @@ export function resolveTurnToolAccess<
   return { tools, subAgents, withheldToolNames, hiddenPlugins };
 }
 
-/**
- * `hiddenPlugins` from the boot-time contributions alone, for the
- * capability router, which predicts before the turn's request-time tools are
- * collected. A plugin whose request-time tools would make it usable may be
- * left out here (the router does not offer it; `load_capability` still
- * can); one whose request-time tools are all withheld may be offered, and
- * the turn's build voids that preload (`createMainAgent`).
- */
-export async function bootHiddenPlugins(input: {
-  registries: { tools: ToolRegistry; subAgents: SubAgentRegistry };
-  buildCtx: PluginContext;
-  has: HasCapability;
-}): Promise<ReadonlySet<string>> {
-  const { registries, buildCtx, has } = input;
-  return resolveTurnToolAccess({
-    tools: await registries.tools.collectBoot(buildCtx),
-    subAgents: registries.subAgents.collectBoot(buildCtx),
-    buildCtx,
-    has,
-    // A failing sub-agent is reported by the turn's build, once.
-    logger: NOOP_LOGGER,
-  }).hiddenPlugins;
-}
-
 /**
  * The manifest as this turn may show it: `examples` naming a withheld tool
  * removed, so neither the Tier-1 prompt nor `load_capability` teaches the

package/src/core/wrap-plugin-tool.ts

@@ -1,5 +1,6 @@
 import { ToolMessage } from '@langchain/core/messages';
 import { Command } from '@langchain/langgraph';
+import { withoutStructuredCopy } from './mcp-result';
 import { capToolResult, type ResultCapConfig } from './middlewares/result-cap';
 import { tool } from '@langchain/core/tools';
 import type { StructuredTool } from 'langchain';
@@ -125,7 +126,7 @@ export function wrapPluginTool(
       );
       if (pluginName !== undefined)
         requireToolPlane(ctx, pluginName, pluginTool);
-      const output = await pluginTool.handler(args, ctx);
+      const output = withoutStructuredCopy(await pluginTool.handler(args, ctx));
       // A tool's own message (a result that says the tool did not run) is
       // returned whole, never capped into text.
       if (

package/src/do/contracts.ts

@@ -271,6 +271,8 @@ export interface OracleWorkerEnv {
   LLM_STREAM_IDLE_TIMEOUT_MS?: string;
   LLM_BYO_STREAM_IDLE_TIMEOUT_MS?: string;
   LLM_STREAM_RETRIES?: string;
+  /** Most tokens one platform model call may generate, reasoning included (default 16384; 0 = the model's limit). */
+  LLM_MAX_OUTPUT_TOKENS?: string;
   /** LangGraph steps one turn may take before `GraphRecursionError` (default 600; Node hard-codes 200). */
   TURN_RECURSION_LIMIT?: string;
   /** Turn budget: tool attempts (default 120) and deadline in ms (600000). */
@@ -295,7 +297,12 @@ export interface OracleWorkerEnv {
   MODEL_CONTEXT_TOKENS?: string;
   MODEL_CONTEXT_OVERRIDES?: string;
   CONTEXT_SUMMARIZE_FRACTION?: string;
+  CONTEXT_SUMMARIZE_MAX_TOKENS?: string;
   CONTEXT_PRUNE_FRACTION?: string;
+  CONTEXT_PRUNE_MAX_TOKENS?: string;
+  CONTEXT_STALE_RESULT_TURNS?: string;
+  CONTEXT_CACHE_COLD_MS?: string;
+  CONTEXT_PLUGIN_IDLE_TURNS?: string;
   CONTEXT_RESULT_CAP_FRACTION?: string;
   CONTEXT_RESULT_CAP_MAX_CHARS?: string;
   CONTEXT_REQUEST_FRACTION?: string;
@@ -327,9 +334,14 @@ export interface OracleWorkerEnv {
   /**
    * Capability router (needs a `DECISION_PROVIDER`). `off` (default) never
    * evaluates; `shadow` evaluates and logs the verdict without preloading;
-   * `on` preloads the predicted on-demand plugin's tools for the turn.
+   * `on` loads the predicted plugins on the thread before the first model
+   * call.
    */
   CAPABILITY_ROUTER?: CapabilityRouterMode;
+  /** The score a preload needs on a warm turn (default 0.8; above 1, never). */
+  CAPABILITY_ROUTER_WARM_THRESHOLD?: string;
+  /** The score a preload needs on a cold turn (default 0.7). */
+  CAPABILITY_ROUTER_COLD_THRESHOLD?: string;
   /** Applies exclusively to authenticated channel admission; Portal/Matrix turns never route. */
   CHANNEL_SEMANTIC_ROUTING?: 'off' | 'shadow' | 'on';
   CHANNEL_SEMANTIC_ROUTING_BINDINGS?: string;

package/src/do/transcript.ts

@@ -140,6 +140,45 @@ export function visibleText(message: BaseMessage): string {
   return contentToText(visibleContent(message));
 }
 
+/**
+ * Whether a stored message is one the user sees in the transcript. System and
+ * tool messages never are, nor a failed reply, nor anything the runtime wrote
+ * for the model about an attachment: the extracted text of a file (an AI
+ * message with an `attachment`) and `view_attachment` re-attaching a payload,
+ * nor a chat gateway's delivery notice.
+ */
+export function visibleToUser(message: BaseMessage): boolean {
+  if (message.type === 'system' || message.type === 'tool') return false;
+  const kw = (message.additional_kwargs ?? {}) as Record<string, unknown>;
+  if (kw.isError) return false;
+  if (message.type === 'ai' && Boolean(kw.attachment)) return false;
+  // A chat gateway's delivery notice: the model's, never a user message.
+  return !isAttachmentViewMessage(message) && !isDeliveryNoticeMessage(message);
+}
+
+/**
+ * The latest turns as the user saw them, oldest first and each as
+ * `user: …` or `assistant: …` cut to `maxChars`, from messages listed newest
+ * first. Only what `visibleToUser` lets through, without summaries and rows
+ * with no visible text.
+ */
+export function recentTurnTexts(
+  newestFirst: readonly BaseMessage[],
+  limit: number,
+  maxChars: number,
+): string[] {
+  const turns: string[] = [];
+  for (const message of newestFirst) {
+    if (turns.length === limit) break;
+    if (isSummarizationMessage(message) || !visibleToUser(message)) continue;
+    const text = visibleText(message).trim();
+    if (!text) continue;
+    const speaker = message.type === 'human' ? 'user' : 'assistant';
+    turns.push(`${speaker}: ${text.slice(0, maxChars)}`);
+  }
+  return turns.reverse();
+}
+
 /**
  * The summarization middleware's bookkeeping message — never shown to users.
  * LangChain 1.4 writes it as a HUMAN message tagged
@@ -171,18 +210,8 @@ export async function transformTranscript(
   for (const message of messages) {
     const toolMsg = message.type === 'tool' ? (message as ToolMessage) : null;
     const kw = (message.additional_kwargs ?? {}) as Record<string, unknown>;
-    const isExtractionContext = message.type === 'ai' && Boolean(kw.attachment);
 
-    if (
-      message.type !== 'system' &&
-      message.type !== 'tool' &&
-      !kw.isError &&
-      !isExtractionContext &&
-      // `view_attachment` re-attaching an offloaded payload — model-facing.
-      !isAttachmentViewMessage(message) &&
-      // A chat gateway's delivery notice — the model's, never a user message.
-      !isDeliveryNoticeMessage(message)
-    ) {
+    if (visibleToUser(message)) {
       const reasoning = reasoningToText(kw.reasoning);
       const attachments =
         message.type === 'human'

package/src/do/turn-metadata.ts

@@ -62,6 +62,16 @@ export interface PriorMetadataState {
   sessionRunId?: string;
   currentEntityDid?: string;
   loadedPlugins?: string[];
+  /** The plugins whose operating guides the prompt carried (`operating-guides.ts`). */
+  promptGuides?: string[];
+  /** The plugins whose usage the thread's messages carry (`operating-guides.ts`). */
+  capabilityUsage?: string[];
+}
+
+function strings(value: unknown): string[] | undefined {
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : undefined;
 }
 
 function priorString(
@@ -75,15 +85,17 @@ function priorString(
 export function priorMetadataState(
   prior: Record<string, unknown>,
 ): PriorMetadataState {
-  const loaded = prior['loadedPlugins'];
+  const loaded = strings(prior['loadedPlugins']);
+  const promptGuides = strings(prior['promptGuides']);
+  const capabilityUsage = strings(prior['capabilityUsage']);
   return {
     editorRoomId: priorString(prior, 'editorRoomId'),
     spaceId: priorString(prior, 'spaceId'),
     sessionRunId: priorString(prior, 'sessionRunId'),
     currentEntityDid: priorString(prior, 'currentEntityDid'),
-    ...(Array.isArray(loaded)
-      ? { loadedPlugins: loaded.filter((p) => typeof p === 'string') }
-      : {}),
+    ...(loaded ? { loadedPlugins: loaded } : {}),
+    ...(promptGuides ? { promptGuides } : {}),
+    ...(capabilityUsage ? { capabilityUsage } : {}),
   };
 }
 

package/src/do/user-oracle-do.ts

@@ -186,9 +186,15 @@ import {
   DEFAULT_MODEL_ID,
 } from '../core/llm';
 import { renderTurnTimeNote } from '../core/prompt-composer';
+import type { RegisteredManifest } from '../core/registries';
+import {
+  TURN_GUIDE_NOTE_KWARG,
+  USAGE_CARRIED_KWARG,
+} from '../core/operating-guides';
 import { TURN_TIME_NOTE_KWARG, withTurnTimeNote } from '../core/turn-time-note';
 import {
   capabilityRouterMode,
+  preloadThreshold,
   createCapabilityRouter,
   shadowAgreement,
   type CapabilityRouter,
@@ -203,7 +209,6 @@ import type {
   RequestAdmissionResult,
   RequestDisposition,
 } from '../plugin-api/request-admission';
-import { bootHiddenPlugins } from '../core/tool-access';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { AmbientServices, LlmAdapter } from '../core/runtime-context';
 import { chatGptBackendFromEnv } from '../llm/byo-client';
@@ -220,6 +225,8 @@ import { parseJwk } from '../secrets/jwe';
 import { WorkersSecretsService } from '../secrets/secrets-service';
 import { createSecretsAdapter } from './secrets-adapter';
 import {
+  EDITOR_PLUGIN_NAME,
+  editorContextActive,
   metadataBuildState,
   metadataGraphInput,
   parseTurnMetadata,
@@ -348,6 +355,7 @@ import {
   pageOfMessages,
   SessionHistoryIndexer,
   type HistoryEntry,
+  conversationReader,
   type HistoryMessage,
   type HistoryPage,
   type IndexableSession,
@@ -455,6 +463,7 @@ import {
   contentToText,
   isSummarizationMessage,
   pageThreadTranscript,
+  recentTurnTexts,
   TranscriptCursorError,
   transformTranscript,
   type TranscriptPageOptions,
@@ -571,6 +580,15 @@ type UserContextSettle = (
   signal: AbortSignal,
 ) => Promise<UserContextData | undefined>;
 
+/**
+ * What the capability router sees of the thread: enough to route a follow-up
+ * (two exchanges, each turn cut short), read from a bounded number of rows so
+ * a long thread costs nothing extra.
+ */
+const ROUTER_RECENT_TURNS = 4;
+const ROUTER_RECENT_TURN_CHARS = 300;
+const ROUTER_RECENT_ROWS = 12;
+
 /** How long a first turn waits on the user-context prefetch before saying so. */
 const USER_CONTEXT_PROGRESS_GRACE_MS = 300;
 const USER_CONTEXT_PROGRESS_STEP = 'Recalling your memories…';
@@ -4787,7 +4805,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
             !isAttachmentViewMessage(m) &&
             !isDeliveryNoticeMessage(m),
         )
-        .map((m) => ({ type: m.type, content: visibleText(m) }));
+        .map(conversationReader());
     }
 
     /**
@@ -4810,6 +4828,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
       }
       const pageRows = Math.max(1, limit);
       const entries: HistoryEntry[] = [];
+      const read = conversationReader();
       for (;;) {
         const rows = await saver.listThreadMessageRows(sessionId, {
           direction: 'newer',
@@ -4826,7 +4845,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
           )
             continue;
           entries.push({
-            message: { type: m.type, content: visibleText(m) },
+            message: read(m),
             cursor: row.messageId,
           });
         }
@@ -5021,6 +5040,8 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
       prior: unknown;
       client: TurnRequest['client'];
       roomKind: TurnRequest['roomKind'];
+      /** The provider's cache has expired, so the prompt may change. */
+      coldTurn: boolean;
     }): UserContextSettle | null {
       // A first contact that fetches nothing still prints the one
       // first-contact line (see the settle step below), with its reason, so
@@ -5075,9 +5096,11 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
         // room answer — but only one already in the cache: an upload that
         // just invalidated the room must not make the next message wait for
         // a gather. On a miss the thread keeps its context and the
-        // (single-flight) refresh warms the cache for a later turn.
+        // (single-flight) refresh warms the cache for a later turn. The
+        // answer sits in the system prompt, so it waits for a cold turn: a
+        // change there re-reads the whole request at the uncached price.
         const warm =
-          input.client === 'channel'
+          input.client === 'channel' && input.coldTurn
             ? fetcher.readCached(input.roomId)
             : undefined;
         keepGathering();
@@ -7178,13 +7201,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
       sessionId: string,
     ): Promise<SessionContextStatus | null> {
       if (!(await this.sessions!.getSession(sessionId))) return null;
-      const tuple = await this.saver!.getTuple({
-        configurable: { thread_id: sessionId },
-      });
-      const channel: unknown = tuple?.checkpoint.channel_values.messages;
-      const context: BaseMessage[] = Array.isArray(channel)
-        ? channel.filter(isBaseMessage)
-        : [];
+      const context = await this.contextMessages(sessionId);
       const thread = await this.saver!.listThreadMessages(sessionId);
       const stats = await this.ctx.storage.get<SessionContextCounters>(
         contextStatsKey(sessionId),
@@ -7204,6 +7221,15 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
       };
     }
 
+    /** The messages the session's model calls start from (a summary, then the kept tail, once condensed). */
+    private async contextMessages(sessionId: string): Promise<BaseMessage[]> {
+      const tuple = await this.saver!.getTuple({
+        configurable: { thread_id: sessionId },
+      });
+      const channel: unknown = tuple?.checkpoint.channel_values.messages;
+      return Array.isArray(channel) ? channel.filter(isBaseMessage) : [];
+    }
+
     /** Fold a guard event into the session's stored counters (ordered, never throws). */
     private recordContextEvent(
       sessionId: string,
@@ -7222,7 +7248,8 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
           switch (event.kind) {
             case 'prune':
               next.prunes += 1;
-              if (event.stage !== 'soft') next.hardPrunes += 1;
+              if (event.stage === 'hard' || event.stage === 'overflow')
+                next.hardPrunes += 1;
               next.prunedResults += event.pruned;
               break;
             case 'overflow-retry':
@@ -7721,6 +7748,13 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
         configurable: { thread_id: req.sessionId },
       });
       const priorState = existing?.checkpoint.channel_values ?? {};
+      // A new thread, or quiet for longer than the provider's cache lives:
+      // this turn pays a miss whatever it sends, so it is the one to change
+      // the prefix on.
+      const coldTurn =
+        !existing ||
+        turnAt.getTime() - Date.parse(existing.checkpoint.ts) >=
+          contextBudget.cacheColdMs;
       // What the memory engine knows about the user, for the prompt's
       // context block: started now so the round-trip overlaps the rest of
       // the build, settled right before the agent is built.
@@ -7734,6 +7768,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
             prior: priorState.userContext,
             client: req.client,
             roomKind: req.roomKind,
+            coldTurn,
           });
 
       // A Matrix turn with no usable delegation: ask the web app to open its
@@ -7862,11 +7897,6 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
         suppliedContextOnly ? {} : priorState,
       );
 
-      // Capability router: predict the on-demand plugin this message needs
-      // and preload it for THIS turn only. `on` is awaited here, ahead of the
-      // first model call; `shadow` returns at once and logs its verdict when
-      // it lands. The preload never enters `stateInput` — the checkpointed
-      // `loadedPlugins` channel is written by `load_capability` alone.
       const priorLoaded: ReadonlySet<string> = new Set(
         priorMeta.loadedPlugins ?? [],
       );
@@ -7885,45 +7915,49 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
             client: req.client,
             env: langsmithEnvFromWorkerEnv(this.env),
           });
-      const preloadedPlugins =
-        !suppliedContextOnly && this.capabilityRouter
-          ? await this.capabilityRouter({
-              mode: capabilityRouterMode(core.validatedEnv.CAPABILITY_ROUTER),
-              manifests: core.registries.manifests.collect(),
-              loaded: priorLoaded,
-              hidden: () =>
-                bootHiddenPlugins({
-                  registries: core.registries,
-                  buildCtx: core.buildCtx(),
-                  has: (resource, action) =>
-                    ambient.ucan.hasCapability(
-                      ucanDelegation,
-                      resource,
-                      action,
+      // Capability router: from what is left to load this turn (the build
+      // works that out from the turn's tools), the plugins this message needs.
+      // `on` is awaited in the build, ahead of the first model call, and the
+      // plugins load on the thread like any other; `shadow` returns at once
+      // and logs its verdict when it lands. A resumed attempt keeps what the
+      // run started with.
+      const router = this.capabilityRouter;
+      const routeCapabilities =
+        !suppliedContextOnly && !run.resumed && router
+          ? (candidates: readonly RegisteredManifest[]) =>
+              router({
+                mode: capabilityRouterMode(core.validatedEnv.CAPABILITY_ROUTER),
+                candidates,
+                ...preloadThreshold(coldTurn, core.validatedEnv),
+                text: body.message,
+                recentTurns: async () =>
+                  recentTurnTexts(
+                    await saver.listRecentThreadMessages(
+                      req.sessionId,
+                      ROUTER_RECENT_ROWS,
                     ),
-                }),
-              hasCapability: (resource, action) =>
-                ambient.ucan.hasCapability(ucanDelegation, resource, action),
-              text: body.message,
-              requestId: req.requestId,
-              signal: abortController.signal,
-              trace: {
-                ...(tracing.callbacks && { callbacks: tracing.callbacks }),
-                // `thread_id` matches the graph run's, so LangSmith's thread
-                // view groups the router span with the turn.
-                metadata: {
-                  ...tracing.metadata,
-                  thread_id: req.sessionId,
-                  request_id: req.requestId,
+                    ROUTER_RECENT_TURNS,
+                    ROUTER_RECENT_TURN_CHARS,
+                  ),
+                requestId: req.requestId,
+                signal: abortController.signal,
+                trace: {
+                  ...(tracing.callbacks && { callbacks: tracing.callbacks }),
+                  // `thread_id` matches the graph run's, so LangSmith's thread
+                  // view groups the router span with the turn.
+                  metadata: {
+                    ...tracing.metadata,
+                    thread_id: req.sessionId,
+                    request_id: req.requestId,
+                  },
                 },
-              },
-              onShadowVerdict: (wouldPreload) =>
-                this.shadowRoutes.set(req.sessionId, {
-                  requestId: req.requestId,
-                  priorLoaded,
-                  wouldPreload,
-                }),
-            })
+                onShadowVerdict: (wouldPreload) =>
+                  this.shadowRoutes.set(req.sessionId, {
+                    requestId: req.requestId,
+                    priorLoaded,
+                    wouldPreload,
+                  }),
+              })
           : undefined;
 
       // Host page-context / safety-guardrail hooks, resolved against this
@@ -8094,13 +8128,44 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
           )
         : undefined;
 
+      // On a cold turn the thread's history shows which capabilities it has
+      // moved on from. The messages are read only then, and only for a
+      // thread with something to unload; the editor stays while its context
+      // is active, and a resumed attempt keeps what the run started with.
+      const unloadable = (priorMeta.loadedPlugins ?? []).filter(
+        (plugin) =>
+          plugin !== EDITOR_PLUGIN_NAME ||
+          !editorContextActive(meta, priorMeta),
+      );
+      const capabilityExpiry =
+        coldTurn &&
+        !run.resumed &&
+        contextBudget.pluginIdleTurns > 0 &&
+        unloadable.length > 0
+          ? {
+              loaded: unloadable,
+              maxIdleTurns: contextBudget.pluginIdleTurns,
+              messages: await this.contextMessages(req.sessionId),
+            }
+          : undefined;
+
       const built = await createMainAgent({
         executionProfile: req.executionProfile,
+        ...(capabilityExpiry ? { capabilityExpiry } : {}),
         registries: core.registries,
         identity: core.identity,
         config: core.validatedEnv,
         availablePlugins: core.availablePlugins,
-        preloadedPlugins,
+        ...(routeCapabilities ? { routeCapabilities } : {}),
+        promptCache: {
+          cold: coldTurn && !run.resumed,
+          ...(priorMeta.promptGuides
+            ? { promptGuides: priorMeta.promptGuides }
+            : {}),
+          ...(priorMeta.capabilityUsage
+            ? { capabilityUsage: priorMeta.capabilityUsage }
+            : {}),
+        },
         byoProvider: byoTurn?.provider,
         contextBudget,
         turnBudget: budget,
@@ -8224,7 +8289,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
         checkpointer: saver,
         abortSignal: abortController.signal,
       });
-      const { agent, context } = built;
+      const { agent, context, guideNote } = built;
       for (const [name, effect] of built.toolEffects)
         toolEffects.set(name, effect);
       for (const [name, surface] of built.toolSurfaces)
@@ -8277,9 +8342,10 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
       const referenced = replyNote
         ? withTurnTimeNote(noticed, replyNote)
         : noticed;
-      const content = timeNote
-        ? withTurnTimeNote(referenced, timeNote)
+      const guided = guideNote
+        ? withTurnTimeNote(referenced, guideNote.text)
         : referenced;
+      const content = timeNote ? withTurnTimeNote(guided, timeNote) : guided;
       const human = new HumanMessage({
         content,
         additional_kwargs: {
@@ -8289,6 +8355,12 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
           ...(noticeNote
             ? { [CHANNEL_DELIVERY_NOTICE_KWARG]: noticeNote }
             : {}),
+          ...(guideNote
+            ? {
+                [TURN_GUIDE_NOTE_KWARG]: guideNote.text,
+                [USAGE_CARRIED_KWARG]: guideNote.plugins,
+              }
+            : {}),
           oracleName: core.identity.name,
           msgFromMatrixRoom: req.client === 'matrix',
           ...speakerKwargs,
@@ -8319,6 +8391,7 @@ export function createUserOracleDO(opts: UserOracleDOOptions) {
         // every slot present; later turns write nothing and keep it.
         ...(userContext ? { userContext } : {}),
         ...metadataGraphInput(meta, priorMeta),
+        ...built.stateUpdate,
         ...surface.input,
       };
       const config = {

package/src/index.ts

@@ -60,6 +60,7 @@ export {
 } from './do/user-oracle-do';
 export type {
   DocumentRequest,
+  DomainBriefDetail,
   DomainCapsuleInspection,
   DomainContextOptions,
   DomainContextPins,