@vellumai/assistant 0.4.26 → 0.4.29

package/src/daemon/session-process.ts

@@ -6,39 +6,44 @@
  * used by session-history.ts.
  */
 
-import { createAssistantMessage,createUserMessage } from '../agent/message-types.js';
-import type { TurnChannelContext, TurnInterfaceContext } from '../channels/types.js';
-import { parseChannelId, parseInterfaceId } from '../channels/types.js';
-import { getConfig } from '../config/loader.js';
 import {
-  listCanonicalGuardianRequests,
-  listPendingCanonicalGuardianRequestsByDestinationConversation,
-} from '../memory/canonical-guardian-store.js';
-import * as conversationStore from '../memory/conversation-store.js';
-import { provenanceFromGuardianContext } from '../memory/conversation-store.js';
-import { extractPreferences } from '../notifications/preference-extractor.js';
-import { createPreference } from '../notifications/preferences-store.js';
-import type { Message } from '../providers/types.js';
-import { routeGuardianReply } from '../runtime/guardian-reply-router.js';
-import { getLogger } from '../util/logger.js';
-import { resolveGuardianVerificationIntent } from './guardian-verification-intent.js';
-import type { UsageStats } from './ipc-contract.js';
-import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
-import type { MessageQueue } from './session-queue-manager.js';
-import type { QueueDrainReason } from './session-queue-manager.js';
-import type { GuardianRuntimeContext } from './session-runtime-assembly.js';
-import { resolveSlash, type SlashContext } from './session-slash.js';
-import type { TraceEmitter } from './trace-emitter.js';
-
-const log = getLogger('session-process');
+  createAssistantMessage,
+  createUserMessage,
+} from "../agent/message-types.js";
+import type {
+  TurnChannelContext,
+  TurnInterfaceContext,
+} from "../channels/types.js";
+import { parseChannelId, parseInterfaceId } from "../channels/types.js";
+import { getConfig } from "../config/loader.js";
+import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
+import * as conversationStore from "../memory/conversation-store.js";
+import { provenanceFromTrustContext } from "../memory/conversation-store.js";
+import { extractPreferences } from "../notifications/preference-extractor.js";
+import { createPreference } from "../notifications/preferences-store.js";
+import type { Message } from "../providers/types.js";
+import { routeGuardianReply } from "../runtime/guardian-reply-router.js";
+import { getLogger } from "../util/logger.js";
+import { resolveGuardianVerificationIntent } from "./guardian-verification-intent.js";
+import type { UsageStats } from "./ipc-contract.js";
+import type { ServerMessage, UserMessageAttachment } from "./ipc-protocol.js";
+import type { MessageQueue } from "./session-queue-manager.js";
+import type { QueueDrainReason } from "./session-queue-manager.js";
+import type { TrustContext } from "./session-runtime-assembly.js";
+import { resolveSlash, type SlashContext } from "./session-slash.js";
+import type { TraceEmitter } from "./trace-emitter.js";
+
+const log = getLogger("session-process");
 
 /** Build a model_info event with fresh config data. */
 function buildModelInfoEvent(): ServerMessage {
   const config = getConfig();
-  const configured = Object.keys(config.apiKeys).filter((k) => !!config.apiKeys[k]);
-  if (!configured.includes('ollama')) configured.push('ollama');
+  const configured = Object.keys(config.apiKeys).filter(
+    (k) => !!config.apiKeys[k],
+  );
+  if (!configured.includes("ollama")) configured.push("ollama");
   return {
-    type: 'model_info',
+    type: "model_info",
     model: config.model,
     provider: config.provider,
     configuredProviders: configured,
@@ -48,7 +53,11 @@ function buildModelInfoEvent(): ServerMessage {
 /** True when the trimmed content is a /model or /models slash command. */
 function isModelSlashCommand(content: string): boolean {
   const trimmed = content.trim();
-  return trimmed === '/model' || trimmed === '/models' || trimmed.startsWith('/model ');
+  return (
+    trimmed === "/model" ||
+    trimmed === "/models" ||
+    trimmed.startsWith("/model ")
+  );
 }
 
 // ── Context Interface ────────────────────────────────────────────────
@@ -74,37 +83,68 @@ export interface ProcessSessionContext {
   preactivatedSkillIds?: string[];
   /** Assistant identity — used for scoping notification preferences. */
   readonly assistantId?: string;
-  guardianContext?: GuardianRuntimeContext;
+  trustContext?: TrustContext;
   ensureActorScopedHistory(): Promise<void>;
-  persistUserMessage(content: string, attachments: UserMessageAttachment[], requestId?: string, metadata?: Record<string, unknown>, displayContent?: string): Promise<string>;
+  persistUserMessage(
+    content: string,
+    attachments: UserMessageAttachment[],
+    requestId?: string,
+    metadata?: Record<string, unknown>,
+    displayContent?: string,
+  ): Promise<string>;
   runAgentLoop(
     content: string,
     userMessageId: string,
     onEvent: (msg: ServerMessage) => void,
-    options?: { skipPreMessageRollback?: boolean; isInteractive?: boolean; isUserMessage?: boolean; titleText?: string },
+    options?: {
+      skipPreMessageRollback?: boolean;
+      isInteractive?: boolean;
+      isUserMessage?: boolean;
+      titleText?: string;
+    },
   ): Promise<void>;
   getTurnChannelContext(): TurnChannelContext | null;
   setTurnChannelContext(ctx: TurnChannelContext): void;
   getTurnInterfaceContext(): TurnInterfaceContext | null;
   setTurnInterfaceContext(ctx: TurnInterfaceContext): void;
   emitActivityState(
-    phase: 'idle' | 'thinking' | 'streaming' | 'tool_running' | 'awaiting_confirmation',
-    reason: 'message_dequeued' | 'thinking_delta' | 'first_text_delta' | 'tool_use_start' | 'tool_result_received' | 'confirmation_requested' | 'confirmation_resolved' | 'message_complete' | 'generation_cancelled' | 'error_terminal',
-    anchor?: 'assistant_turn' | 'user_turn' | 'global',
+    phase:
+      | "idle"
+      | "thinking"
+      | "streaming"
+      | "tool_running"
+      | "awaiting_confirmation",
+    reason:
+      | "message_dequeued"
+      | "thinking_delta"
+      | "first_text_delta"
+      | "tool_use_start"
+      | "tool_result_received"
+      | "confirmation_requested"
+      | "confirmation_resolved"
+      | "message_complete"
+      | "generation_cancelled"
+      | "error_terminal",
+    anchor?: "assistant_turn" | "user_turn" | "global",
     requestId?: string,
     statusText?: string,
   ): void;
 }
 
 function resolveQueuedTurnContext(
-  queued: { turnChannelContext?: TurnChannelContext; metadata?: Record<string, unknown> },
+  queued: {
+    turnChannelContext?: TurnChannelContext;
+    metadata?: Record<string, unknown>;
+  },
   fallback: TurnChannelContext | null,
 ): TurnChannelContext | null {
   if (queued.turnChannelContext) return queued.turnChannelContext;
   const metadata = queued.metadata;
   if (metadata) {
     const userMessageChannel = parseChannelId(metadata.userMessageChannel);
-    const assistantMessageChannel = parseChannelId(metadata.assistantMessageChannel);
+    const assistantMessageChannel = parseChannelId(
+      metadata.assistantMessageChannel,
+    );
     if (userMessageChannel && assistantMessageChannel) {
       return { userMessageChannel, assistantMessageChannel };
     }
@@ -113,14 +153,21 @@ function resolveQueuedTurnContext(
 }
 
 function resolveQueuedTurnInterfaceContext(
-  queued: { turnInterfaceContext?: TurnInterfaceContext; metadata?: Record<string, unknown> },
+  queued: {
+    turnInterfaceContext?: TurnInterfaceContext;
+    metadata?: Record<string, unknown>;
+  },
   fallback: TurnInterfaceContext | null,
 ): TurnInterfaceContext | null {
   if (queued.turnInterfaceContext) return queued.turnInterfaceContext;
   const metadata = queued.metadata;
   if (metadata) {
-    const userMessageInterface = parseInterfaceId(metadata.userMessageInterface);
-    const assistantMessageInterface = parseInterfaceId(metadata.assistantMessageInterface);
+    const userMessageInterface = parseInterfaceId(
+      metadata.userMessageInterface,
+    );
+    const assistantMessageInterface = parseInterfaceId(
+      metadata.assistantMessageInterface,
+    );
     if (userMessageInterface && assistantMessageInterface) {
       return { userMessageInterface, assistantMessageInterface };
     }
@@ -154,29 +201,54 @@ function buildSlashContext(session: ProcessSessionContext): SlashContext {
  * block, we must explicitly continue draining on failure — otherwise
  * remaining queued messages would be stranded.
  */
-export async function drainQueue(session: ProcessSessionContext, reason: QueueDrainReason = 'loop_complete'): Promise<void> {
+export async function drainQueue(
+  session: ProcessSessionContext,
+  reason: QueueDrainReason = "loop_complete",
+): Promise<void> {
   const next = session.queue.shift();
   if (!next) return;
 
-  log.info({ conversationId: session.conversationId, requestId: next.requestId, reason }, 'Dequeuing message');
-  session.traceEmitter.emit('request_dequeued', `Message dequeued (${reason})`, {
-    requestId: next.requestId,
-    status: 'info',
-    attributes: { reason },
-  });
+  log.info(
+    {
+      conversationId: session.conversationId,
+      requestId: next.requestId,
+      reason,
+    },
+    "Dequeuing message",
+  );
+  session.traceEmitter.emit(
+    "request_dequeued",
+    `Message dequeued (${reason})`,
+    {
+      requestId: next.requestId,
+      status: "info",
+      attributes: { reason },
+    },
+  );
   next.onEvent({
-    type: 'message_dequeued',
+    type: "message_dequeued",
     sessionId: session.conversationId,
     requestId: next.requestId,
   });
-  session.emitActivityState('thinking', 'message_dequeued', 'assistant_turn', next.requestId);
-
-  const queuedTurnCtx = resolveQueuedTurnContext(next, session.getTurnChannelContext());
+  session.emitActivityState(
+    "thinking",
+    "message_dequeued",
+    "assistant_turn",
+    next.requestId,
+  );
+
+  const queuedTurnCtx = resolveQueuedTurnContext(
+    next,
+    session.getTurnChannelContext(),
+  );
   if (queuedTurnCtx) {
     session.setTurnChannelContext(queuedTurnCtx);
   }
 
-  const queuedInterfaceCtx = resolveQueuedTurnInterfaceContext(next, session.getTurnInterfaceContext());
+  const queuedInterfaceCtx = resolveQueuedTurnInterfaceContext(
+    next,
+    session.getTurnInterfaceContext(),
+  );
   if (queuedInterfaceCtx) {
     session.setTurnInterfaceContext(queuedInterfaceCtx);
   }
@@ -187,16 +259,23 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
   // Unknown slash — persist the exchange and continue draining.
   // Persist each message before pushing to session.messages so that a
   // failed write never leaves an unpersisted message in memory.
-  if (slashResult.kind === 'unknown') {
+  if (slashResult.kind === "unknown") {
     try {
-      const drainProvenance = provenanceFromGuardianContext(session.guardianContext);
+      const drainProvenance = provenanceFromTrustContext(session.trustContext);
       const drainChannelMeta = {
         ...drainProvenance,
         ...(queuedTurnCtx
-          ? { userMessageChannel: queuedTurnCtx.userMessageChannel, assistantMessageChannel: queuedTurnCtx.assistantMessageChannel }
+          ? {
+              userMessageChannel: queuedTurnCtx.userMessageChannel,
+              assistantMessageChannel: queuedTurnCtx.assistantMessageChannel,
+            }
           : {}),
         ...(queuedInterfaceCtx
-          ? { userMessageInterface: queuedInterfaceCtx.userMessageInterface, assistantMessageInterface: queuedInterfaceCtx.assistantMessageInterface }
+          ? {
+              userMessageInterface: queuedInterfaceCtx.userMessageInterface,
+              assistantMessageInterface:
+                queuedInterfaceCtx.assistantMessageInterface,
+            }
           : {}),
       };
       const userMsg = createUserMessage(next.content, next.attachments);
@@ -204,11 +283,13 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
       // intent stripping), persist that to DB so users see the full message.
       // The in-memory userMessage (sent to the LLM) still uses the stripped content.
       const contentToPersist = next.displayContent
-        ? JSON.stringify(createUserMessage(next.displayContent, next.attachments).content)
+        ? JSON.stringify(
+            createUserMessage(next.displayContent, next.attachments).content,
+          )
         : JSON.stringify(userMsg.content);
       await conversationStore.addMessage(
         session.conversationId,
-        'user',
+        "user",
         contentToPersist,
         drainChannelMeta,
       );
@@ -217,17 +298,23 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
       const assistantMsg = createAssistantMessage(slashResult.message);
       await conversationStore.addMessage(
         session.conversationId,
-        'assistant',
+        "assistant",
         JSON.stringify(assistantMsg.content),
         drainChannelMeta,
       );
       session.messages.push(assistantMsg);
 
       if (queuedTurnCtx) {
-        conversationStore.setConversationOriginChannelIfUnset(session.conversationId, queuedTurnCtx.userMessageChannel);
+        conversationStore.setConversationOriginChannelIfUnset(
+          session.conversationId,
+          queuedTurnCtx.userMessageChannel,
+        );
       }
       if (queuedInterfaceCtx) {
-        conversationStore.setConversationOriginInterfaceIfUnset(session.conversationId, queuedInterfaceCtx.userMessageInterface);
+        conversationStore.setConversationOriginInterfaceIfUnset(
+          session.conversationId,
+          queuedInterfaceCtx.userMessageInterface,
+        );
       }
 
       // Emit fresh model info before the text delta so the client has
@@ -235,21 +322,39 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
       if (isModelSlashCommand(next.content)) {
         next.onEvent(buildModelInfoEvent());
       }
-      next.onEvent({ type: 'assistant_text_delta', text: slashResult.message });
-      session.traceEmitter.emit('message_complete', 'Unknown slash command handled', {
-        requestId: next.requestId,
-        status: 'success',
+      next.onEvent({ type: "assistant_text_delta", text: slashResult.message });
+      session.traceEmitter.emit(
+        "message_complete",
+        "Unknown slash command handled",
+        {
+          requestId: next.requestId,
+          status: "success",
+        },
+      );
+      next.onEvent({
+        type: "message_complete",
+        sessionId: session.conversationId,
       });
-      next.onEvent({ type: 'message_complete', sessionId: session.conversationId });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log.error({ err, conversationId: session.conversationId, requestId: next.requestId }, 'Failed to persist unknown-slash exchange');
-      session.traceEmitter.emit('request_error', `Unknown-slash persist failed: ${message}`, {
-        requestId: next.requestId,
-        status: 'error',
-        attributes: { reason: 'persist_failure' },
-      });
-      next.onEvent({ type: 'error', message });
+      log.error(
+        {
+          err,
+          conversationId: session.conversationId,
+          requestId: next.requestId,
+        },
+        "Failed to persist unknown-slash exchange",
+      );
+      session.traceEmitter.emit(
+        "request_error",
+        `Unknown-slash persist failed: ${message}`,
+        {
+          requestId: next.requestId,
+          status: "error",
+          attributes: { reason: "persist_failure" },
+        },
+      );
+      next.onEvent({ type: "error", message });
     }
     // Continue draining regardless of success/failure
     await drainQueue(session);
@@ -259,7 +364,7 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
   const resolvedContent = slashResult.content;
 
   // Preactivate skill tools when slash resolution identifies a known skill
-  if (slashResult.kind === 'rewritten') {
+  if (slashResult.kind === "rewritten") {
     session.preactivatedSkillIds = [slashResult.skillId];
   }
 
@@ -267,12 +372,18 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
   // Preserve the original user content for persistence; only the agent
   // loop receives the rewritten instruction.
   let agentLoopContent = resolvedContent;
-  if (slashResult.kind === 'passthrough') {
+  if (slashResult.kind === "passthrough") {
     const guardianIntent = resolveGuardianVerificationIntent(resolvedContent);
-    if (guardianIntent.kind === 'direct_setup') {
-      log.info({ conversationId: session.conversationId, channelHint: guardianIntent.channelHint }, 'Guardian verification intent intercepted in queue — forcing skill flow');
+    if (guardianIntent.kind === "direct_setup") {
+      log.info(
+        {
+          conversationId: session.conversationId,
+          channelHint: guardianIntent.channelHint,
+        },
+        "Guardian verification intent intercepted in queue — forcing skill flow",
+      );
       agentLoopContent = guardianIntent.rewrittenContent;
-      session.preactivatedSkillIds = ['guardian-verify-setup'];
+      session.preactivatedSkillIds = ["guardian-verify-setup"];
     }
   }
 
@@ -282,16 +393,33 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
   // resolves early (no runAgentLoop call), so we must continue draining.
   let userMessageId: string;
   try {
-    userMessageId = await session.persistUserMessage(resolvedContent, next.attachments, next.requestId, next.metadata, next.displayContent);
+    userMessageId = await session.persistUserMessage(
+      resolvedContent,
+      next.attachments,
+      next.requestId,
+      next.metadata,
+      next.displayContent,
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err, conversationId: session.conversationId, requestId: next.requestId }, 'Failed to persist queued message');
-    session.traceEmitter.emit('request_error', `Queued message persist failed: ${message}`, {
-      requestId: next.requestId,
-      status: 'error',
-      attributes: { reason: 'persist_failure' },
-    });
-    next.onEvent({ type: 'error', message });
+    log.error(
+      {
+        err,
+        conversationId: session.conversationId,
+        requestId: next.requestId,
+      },
+      "Failed to persist queued message",
+    );
+    session.traceEmitter.emit(
+      "request_error",
+      `Queued message persist failed: ${message}`,
+      {
+        requestId: next.requestId,
+        status: "error",
+        attributes: { reason: "persist_failure" },
+      },
+    );
+    next.onEvent({ type: "error", message });
     // runAgentLoop never ran, so its finally block won't clear this
     session.preactivatedSkillIds = undefined;
     // Continue draining — don't strand remaining messages
@@ -318,26 +446,58 @@ export async function drainQueue(session: ProcessSessionContext, reason: QueueDr
             priority: pref.priority,
           });
         }
-        log.info({ count: result.preferences.length, conversationId: session.conversationId }, 'Persisted extracted notification preferences (queued)');
+        log.info(
+          {
+            count: result.preferences.length,
+            conversationId: session.conversationId,
+          },
+          "Persisted extracted notification preferences (queued)",
+        );
       })
       .catch((err) => {
         const errMsg = err instanceof Error ? err.message : String(err);
-        log.warn({ err: errMsg, conversationId: session.conversationId }, 'Background preference extraction failed (queued)');
+        log.warn(
+          { err: errMsg, conversationId: session.conversationId },
+          "Background preference extraction failed (queued)",
+        );
       });
   }
 
   // Fire-and-forget: persistUserMessage set session.processing = true
   // so subsequent messages will still be enqueued.
   // runAgentLoop's finally block will call drainQueue when this run completes.
-  const drainLoopOptions: { isInteractive?: boolean; isUserMessage?: boolean; titleText?: string } = { isUserMessage: true };
-  if (next.isInteractive !== undefined) drainLoopOptions.isInteractive = next.isInteractive;
-  if (agentLoopContent !== resolvedContent) drainLoopOptions.titleText = resolvedContent;
-
-  session.runAgentLoop(agentLoopContent, userMessageId, next.onEvent, drainLoopOptions).catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err, conversationId: session.conversationId, requestId: next.requestId }, 'Error processing queued message');
-    next.onEvent({ type: 'error', message: `Failed to process queued message: ${message}` });
-  });
+  const drainLoopOptions: {
+    isInteractive?: boolean;
+    isUserMessage?: boolean;
+    titleText?: string;
+  } = { isUserMessage: true };
+  if (next.isInteractive !== undefined)
+    drainLoopOptions.isInteractive = next.isInteractive;
+  if (agentLoopContent !== resolvedContent)
+    drainLoopOptions.titleText = resolvedContent;
+
+  session
+    .runAgentLoop(
+      agentLoopContent,
+      userMessageId,
+      next.onEvent,
+      drainLoopOptions,
+    )
+    .catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        {
+          err,
+          conversationId: session.conversationId,
+          requestId: next.requestId,
+        },
+        "Error processing queued message",
+      );
+      next.onEvent({
+        type: "error",
+        message: `Failed to process queued message: ${message}`,
+      });
+    });
 }
 
 // ── processMessage ───────────────────────────────────────────────────
@@ -361,18 +521,17 @@ export async function processMessage(
   session.currentActiveSurfaceId = activeSurfaceId;
   session.currentPage = currentPage;
   const trimmedContent = content.trim();
-  const canonicalPendingRequestHintIdsForConversation = trimmedContent.length > 0
-    ? Array.from(new Set([
-        ...listPendingCanonicalGuardianRequestsByDestinationConversation(session.conversationId, 'vellum').map((request) => request.id),
-        ...listCanonicalGuardianRequests({
-          status: 'pending',
-          conversationId: session.conversationId,
-        }).map((request) => request.id),
-      ]))
-    : [];
-  const canonicalPendingRequestIdsForConversation = canonicalPendingRequestHintIdsForConversation.length > 0
-    ? canonicalPendingRequestHintIdsForConversation
-    : undefined;
+  const canonicalPendingRequestHintIdsForConversation =
+    trimmedContent.length > 0
+      ? listPendingRequestsByConversationScope(
+          session.conversationId,
+          "vellum",
+        ).map((request) => request.id)
+      : [];
+  const canonicalPendingRequestIdsForConversation =
+    canonicalPendingRequestHintIdsForConversation.length > 0
+      ? canonicalPendingRequestHintIdsForConversation
+      : undefined;
 
   // ── Canonical guardian reply router (desktop/session path) ──
   // Desktop/session guardian replies are canonical-only. Messages consumed
@@ -380,11 +539,12 @@ export async function processMessage(
   if (trimmedContent.length > 0) {
     const routerResult = await routeGuardianReply({
       messageText: trimmedContent,
-      channel: 'vellum',
+      channel: "vellum",
       actor: {
-        externalUserId: session.guardianContext?.guardianExternalUserId,
-        channel: 'vellum',
-        guardianPrincipalId: session.guardianContext?.guardianPrincipalId ?? undefined,
+        externalUserId: session.trustContext?.guardianExternalUserId,
+        channel: "vellum",
+        guardianPrincipalId:
+          session.trustContext?.guardianPrincipalId ?? undefined,
       },
       conversationId: session.conversationId,
       pendingRequestIds: canonicalPendingRequestIdsForConversation,
@@ -397,39 +557,47 @@ export async function processMessage(
     if (routerResult.consumed) {
       const guardianIfCtx = session.getTurnInterfaceContext();
       const routerChannelMeta = {
-        userMessageChannel: 'vellum' as const,
-        assistantMessageChannel: 'vellum' as const,
-        userMessageInterface: guardianIfCtx?.userMessageInterface ?? 'vellum',
-        assistantMessageInterface: guardianIfCtx?.assistantMessageInterface ?? 'vellum',
-        provenanceTrustClass: 'guardian' as const,
+        userMessageChannel: "vellum" as const,
+        assistantMessageChannel: "vellum" as const,
+        userMessageInterface: guardianIfCtx?.userMessageInterface ?? "vellum",
+        assistantMessageInterface:
+          guardianIfCtx?.assistantMessageInterface ?? "vellum",
+        provenanceTrustClass: "guardian" as const,
       };
 
       const userMsg = createUserMessage(content, attachments);
       const persisted = await conversationStore.addMessage(
         session.conversationId,
-        'user',
+        "user",
         JSON.stringify(userMsg.content),
         routerChannelMeta,
       );
       session.messages.push(userMsg);
 
-      const replyText = routerResult.replyText
-        ?? (routerResult.decisionApplied ? 'Decision applied.' : 'Request already resolved.');
+      const replyText =
+        routerResult.replyText ??
+        (routerResult.decisionApplied
+          ? "Decision applied."
+          : "Request already resolved.");
       const assistantMsg = createAssistantMessage(replyText);
       await conversationStore.addMessage(
         session.conversationId,
-        'assistant',
+        "assistant",
         JSON.stringify(assistantMsg.content),
         routerChannelMeta,
       );
       session.messages.push(assistantMsg);
 
-      onEvent({ type: 'assistant_text_delta', text: replyText });
-      onEvent({ type: 'message_complete', sessionId: session.conversationId });
+      onEvent({ type: "assistant_text_delta", text: replyText });
+      onEvent({ type: "message_complete", sessionId: session.conversationId });
 
       log.info(
-        { conversationId: session.conversationId, routerType: routerResult.type, requestId: routerResult.requestId },
-        'Session guardian reply routed through canonical pipeline',
+        {
+          conversationId: session.conversationId,
+          routerType: routerResult.type,
+          requestId: routerResult.requestId,
+        },
+        "Session guardian reply routed through canonical pipeline",
       );
 
       return persisted.id;
@@ -442,17 +610,23 @@ export async function processMessage(
   // Unknown slash command — persist the exchange (user + assistant) so the
   // messageId is real.  Persist each message before pushing to session.messages
   // so that a failed write never leaves an unpersisted message in memory.
-  if (slashResult.kind === 'unknown') {
+  if (slashResult.kind === "unknown") {
     const pmTurnCtx = session.getTurnChannelContext();
     const pmInterfaceCtx = session.getTurnInterfaceContext();
-    const pmProvenance = provenanceFromGuardianContext(session.guardianContext);
+    const pmProvenance = provenanceFromTrustContext(session.trustContext);
     const pmChannelMeta = {
       ...pmProvenance,
       ...(pmTurnCtx
-        ? { userMessageChannel: pmTurnCtx.userMessageChannel, assistantMessageChannel: pmTurnCtx.assistantMessageChannel }
+        ? {
+            userMessageChannel: pmTurnCtx.userMessageChannel,
+            assistantMessageChannel: pmTurnCtx.assistantMessageChannel,
+          }
         : {}),
       ...(pmInterfaceCtx
-        ? { userMessageInterface: pmInterfaceCtx.userMessageInterface, assistantMessageInterface: pmInterfaceCtx.assistantMessageInterface }
+        ? {
+            userMessageInterface: pmInterfaceCtx.userMessageInterface,
+            assistantMessageInterface: pmInterfaceCtx.assistantMessageInterface,
+          }
         : {}),
     };
     const userMsg = createUserMessage(content, attachments);
@@ -464,7 +638,7 @@ export async function processMessage(
       : JSON.stringify(userMsg.content);
     const persisted = await conversationStore.addMessage(
       session.conversationId,
-      'user',
+      "user",
       contentToPersist,
       pmChannelMeta,
     );
@@ -473,17 +647,23 @@ export async function processMessage(
     const assistantMsg = createAssistantMessage(slashResult.message);
     await conversationStore.addMessage(
       session.conversationId,
-      'assistant',
+      "assistant",
       JSON.stringify(assistantMsg.content),
       pmChannelMeta,
     );
     session.messages.push(assistantMsg);
 
     if (pmTurnCtx) {
-      conversationStore.setConversationOriginChannelIfUnset(session.conversationId, pmTurnCtx.userMessageChannel);
+      conversationStore.setConversationOriginChannelIfUnset(
+        session.conversationId,
+        pmTurnCtx.userMessageChannel,
+      );
     }
     if (pmInterfaceCtx) {
-      conversationStore.setConversationOriginInterfaceIfUnset(session.conversationId, pmInterfaceCtx.userMessageInterface);
+      conversationStore.setConversationOriginInterfaceIfUnset(
+        session.conversationId,
+        pmInterfaceCtx.userMessageInterface,
+      );
     }
 
     // Emit fresh model info before the text delta so the client has
@@ -491,19 +671,23 @@ export async function processMessage(
     if (isModelSlashCommand(content)) {
       onEvent(buildModelInfoEvent());
     }
-    onEvent({ type: 'assistant_text_delta', text: slashResult.message });
-    session.traceEmitter.emit('message_complete', 'Unknown slash command handled', {
-      requestId,
-      status: 'success',
-    });
-    onEvent({ type: 'message_complete', sessionId: session.conversationId });
+    onEvent({ type: "assistant_text_delta", text: slashResult.message });
+    session.traceEmitter.emit(
+      "message_complete",
+      "Unknown slash command handled",
+      {
+        requestId,
+        status: "success",
+      },
+    );
+    onEvent({ type: "message_complete", sessionId: session.conversationId });
     return persisted.id;
   }
 
   const resolvedContent = slashResult.content;
 
   // Preactivate skill tools when slash resolution identifies a known skill
-  if (slashResult.kind === 'rewritten') {
+  if (slashResult.kind === "rewritten") {
     session.preactivatedSkillIds = [slashResult.skillId];
   }
 
@@ -513,24 +697,36 @@ export async function processMessage(
   // We keep the original user content for persistence and use the
   // rewritten content only for the agent loop instruction.
   let agentLoopContent = resolvedContent;
-  if (slashResult.kind === 'passthrough') {
+  if (slashResult.kind === "passthrough") {
     const guardianIntent = resolveGuardianVerificationIntent(resolvedContent);
-    if (guardianIntent.kind === 'direct_setup') {
-      log.info({ conversationId: session.conversationId, channelHint: guardianIntent.channelHint }, 'Guardian verification intent intercepted — forcing skill flow');
+    if (guardianIntent.kind === "direct_setup") {
+      log.info(
+        {
+          conversationId: session.conversationId,
+          channelHint: guardianIntent.channelHint,
+        },
+        "Guardian verification intent intercepted — forcing skill flow",
+      );
       agentLoopContent = guardianIntent.rewrittenContent;
-      session.preactivatedSkillIds = ['guardian-verify-setup'];
+      session.preactivatedSkillIds = ["guardian-verify-setup"];
     }
   }
 
   let userMessageId: string;
   try {
-    userMessageId = await session.persistUserMessage(resolvedContent, attachments, requestId, undefined, displayContent);
+    userMessageId = await session.persistUserMessage(
+      resolvedContent,
+      attachments,
+      requestId,
+      undefined,
+      displayContent,
+    );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    onEvent({ type: 'error', message });
+    onEvent({ type: "error", message });
     // runAgentLoop never ran, so its finally block won't clear this
     session.preactivatedSkillIds = undefined;
-    return '';
+    return "";
   }
 
   // Fire-and-forget: detect notification preferences in the user message
@@ -549,18 +745,38 @@ export async function processMessage(
             priority: pref.priority,
           });
         }
-        log.info({ count: result.preferences.length, conversationId: session.conversationId }, 'Persisted extracted notification preferences');
+        log.info(
+          {
+            count: result.preferences.length,
+            conversationId: session.conversationId,
+          },
+          "Persisted extracted notification preferences",
+        );
       })
       .catch((err) => {
         const errMsg = err instanceof Error ? err.message : String(err);
-        log.warn({ err: errMsg, conversationId: session.conversationId }, 'Background preference extraction failed');
+        log.warn(
+          { err: errMsg, conversationId: session.conversationId },
+          "Background preference extraction failed",
+        );
       });
   }
 
-  const loopOptions: { isInteractive?: boolean; isUserMessage?: boolean; titleText?: string } = { isUserMessage: true };
-  if (options?.isInteractive !== undefined) loopOptions.isInteractive = options.isInteractive;
-  if (agentLoopContent !== resolvedContent) loopOptions.titleText = resolvedContent;
-
-  await session.runAgentLoop(agentLoopContent, userMessageId, onEvent, loopOptions);
+  const loopOptions: {
+    isInteractive?: boolean;
+    isUserMessage?: boolean;
+    titleText?: string;
+  } = { isUserMessage: true };
+  if (options?.isInteractive !== undefined)
+    loopOptions.isInteractive = options.isInteractive;
+  if (agentLoopContent !== resolvedContent)
+    loopOptions.titleText = resolvedContent;
+
+  await session.runAgentLoop(
+    agentLoopContent,
+    userMessageId,
+    onEvent,
+    loopOptions,
+  );
   return userMessageId;
 }