@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/daemon/conversation-agent-loop.ts

@@ -27,9 +27,7 @@ import {
   resolveEffectiveContextWindow,
 } from "../config/llm-context-resolution.js";
 import {
-  isOverrideOrDefaultResolutionEnabled,
   resolveCallSiteConfig,
-  resolveDefaultProfileKey,
   resolveEffectiveProfileKey,
   resolveProfilelessModelKey,
   selectWinningProfile,
@@ -256,6 +254,16 @@ async function withAbortWatchdog<T>(
 
 // ── runAgentLoop ─────────────────────────────────────────────────────
 
+/**
+ * Steering block appended to the tail user message on turns whose
+ * triggering message carries `messageSource: "nav_redirect"` — a UI
+ * shortcut sent the message on the user's behalf while the user was
+ * exploring the interface. Without it the model treats the canned prompt
+ * as a hand-typed question and answers with a capability tour.
+ */
+const NAV_REDIRECT_STEERING_BLOCK =
+  "<system_reminder>\nThis message was sent by a UI shortcut while the user explored the interface, not typed by hand. Reply in a few sentences at most and end with one concrete, specific next step or question — do not enumerate capabilities or give a tour.\n</system_reminder>";
+
 export async function runAgentLoopImpl(
   ctx: Conversation,
   content: string,
@@ -272,6 +280,15 @@ export async function runAgentLoopImpl(
      * the turn.
      */
     isHiddenPrompt?: boolean;
+    /**
+     * How the triggering message was initiated when it was sent on the
+     * user's behalf by the UI rather than typed by hand (`body.source` on
+     * `POST /v1/messages`, persisted as `metadata.userMessageSource`).
+     * Current value: `"nav_redirect"`, which steers the turn toward a
+     * brief, concrete reply. Forwarded onto the user-prompt-submit hook
+     * context. Unset for hand-typed messages.
+     */
+    messageSource?: string;
     /**
      * LLM call-site identifier threaded into the per-call provider config.
      * Adapter callers (heartbeat, filing, scheduler, etc.) pass their own
@@ -367,7 +384,7 @@ export async function runAgentLoopImpl(
   // contexts (heartbeat, filing, analyze, etc.) pass their own `callSite`. The
   // provider layer resolves provider/model/maxTokens via `resolveCallSiteConfig`,
   // picking up any user overrides under `llm.callSites.<id>` (falling back to
-  // `llm.default` when absent). `resolveTurnCallSite` keeps subagent
+  // the shipped call-site defaults when absent). `resolveTurnCallSite` keeps subagent
   // conversations on `subagentSpawn` when no call site is supplied.
   const turnCallSite = resolveTurnCallSite(options?.callSite, ctx);
   // Expose the turn's call site on the live conversation so the runtime
@@ -931,21 +948,16 @@ export async function runAgentLoopImpl(
     // `modelProfileKey` is the actual profile used for this turn. The
     // notice key is narrower: it only marks turns where runtime context should
     // remind the model that the profile changed.
-    // Under override-or-default semantics the reported key must come from
-    // the same winner selection dispatch used — a hand-rolled chain would
-    // credit profiles the resolver never consulted (e.g. activeProfile on a
-    // non-mainAgent turn).
+    // The reported key must come from the same winner selection dispatch used —
+    // a hand-rolled chain would credit profiles the resolver never consulted
+    // (e.g. activeProfile on a non-mainAgent turn).
     const effectiveProfileKey =
-      (isOverrideOrDefaultResolutionEnabled()
-        ? selectWinningProfile(turnCallSite, config.llm, {
-            ...(turnOverrideProfile != null
-              ? { overrideProfile: turnOverrideProfile }
-              : {}),
-            selectionSeed: ctx.conversationId,
-          }).profileName
-        : (turnOverrideProfile ??
-          config.llm.activeProfile ??
-          resolveDefaultProfileKey("mainAgent", config.llm))) ??
+      selectWinningProfile(turnCallSite, config.llm, {
+        ...(turnOverrideProfile != null
+          ? { overrideProfile: turnOverrideProfile }
+          : {}),
+        selectionSeed: ctx.conversationId,
+      }).profileName ??
       resolveProfilelessModelKey(turnCallSite, config.llm, {
         ...(turnOverrideProfile != null
           ? { overrideProfile: turnOverrideProfile }
@@ -988,6 +1000,9 @@ export async function runAgentLoopImpl(
       requestId: reqId,
       prompt: options?.titleText ?? content,
       isHiddenPrompt: options?.isHiddenPrompt === true,
+      ...(options?.messageSource
+        ? { messageSource: options.messageSource }
+        : {}),
       originalMessages: Object.freeze([...ctx.messages]),
       latestMessages: ctx.messages,
       modelProfileKey,
@@ -999,7 +1014,29 @@ export async function runAgentLoopImpl(
       userPromptCtx,
     );
     latencyTracker.mark("prompt_hook_end");
-    const runMessages = finalUserPromptCtx.latestMessages;
+    let runMessages = finalUserPromptCtx.latestMessages;
+
+    // UI-shortcut steering: appended after the hook chain so it lands below
+    // the assembled runtime injections on the tail user message, mirroring
+    // the non-interactive block's placement in `applyRuntimeInjections`.
+    // Turn-scoped nudge, deliberately not persisted for byte-exact reload
+    // rehydration — losing it on reload costs one prefix-cache anchor, not
+    // context correctness.
+    if (options?.messageSource === "nav_redirect") {
+      const userTail = runMessages[runMessages.length - 1];
+      if (userTail && userTail.role === "user") {
+        runMessages = [
+          ...runMessages.slice(0, -1),
+          {
+            ...userTail,
+            content: [
+              ...userTail.content,
+              { type: "text" as const, text: NAV_REDIRECT_STEERING_BLOCK },
+            ],
+          },
+        ];
+      }
+    }
 
     // Reset the manager's turn-scoped overflow-recovery ladder at the turn
     // boundary so a new turn starts the ladder fresh from the emergency rung.
@@ -1590,6 +1627,21 @@ export async function runAgentLoopImpl(
       publishLoopMessagesChanged();
     }
   } finally {
+    // Clear the processing flag first. It is the release that frees the
+    // conversation for its next turn, so nothing that can throw (the
+    // turn-boundary commit, profiling) is allowed to run ahead of it and leave
+    // the row latched "mid-turn". Stamp the turn's abnormal outcome first
+    // because the telemetry reporter's settled-turn barrier only releases this
+    // turn once processing stops; null `abortController` first so a concurrent
+    // abort takes the force-clear branch rather than signalling a dead one.
+    if (abnormalOutcome) {
+      stampTurnOutcome(userMessageId, abnormalOutcome.outcome, {
+        failureCode: abnormalOutcome.failureCode,
+      });
+    }
+    ctx.abortController = null;
+    ctx.setProcessing(false);
+
     if (turnStarted) {
       ctx.turnCount++;
       const config = getConfig();
@@ -1625,24 +1677,12 @@ export async function runAgentLoopImpl(
 
     emitToolProfilingSummary(ctx.conversationId, reqId);
 
-    // Tear down this turn's per-turn state. Abort reliably drives the loop to
+    // Tear down the remaining per-turn state. Abort reliably drives the loop to
     // this `finally` within a bounded time — cooperative signal propagation
     // (provider fetch + tool race) backed by the abort watchdog — so a
     // cancelled turn always unwinds before any resend can start a new one.
     // There is therefore only ever one turn alive, and clearing the shared
     // state below cannot clobber a concurrent turn.
-    // Stamp the turn's abnormal outcome (failed / cancelled) onto its
-    // user-message row BEFORE processing clears: the telemetry reporter's
-    // settled-turn barrier only releases this turn once the conversation
-    // stops processing, so ordering the stamp first guarantees the turn
-    // event ships with the outcome. A normally-replied turn stamps nothing.
-    if (abnormalOutcome) {
-      stampTurnOutcome(userMessageId, abnormalOutcome.outcome, {
-        failureCode: abnormalOutcome.failureCode,
-      });
-    }
-    ctx.abortController = null;
-    ctx.setProcessing(false);
     ctx.onConfirmationOutcome = undefined;
     ctx.surfaceActionRequestIds.delete(ctx.currentRequestId ?? "");
     ctx.approvedViaPromptThisTurn = false;

package/src/daemon/conversation-error.ts

@@ -198,13 +198,21 @@ export interface ErrorContext {
  * recognized as cancellation too.
  */
 export function isUserCancellation(error: unknown, ctx: ErrorContext): boolean {
-  if (!ctx.aborted) return false;
-  if (error instanceof DOMException && error.name === "AbortError") return true;
-  if (error instanceof Error && error.name === "AbortError") return true;
+  if (!ctx.aborted) {
+    return false;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
   if (error instanceof ProviderError && isAbortReason(error.abortReason)) {
     return true;
   }
-  if (isAbortReason(error)) return true;
+  if (isAbortReason(error)) {
+    return true;
+  }
   return false;
 }
 
@@ -215,7 +223,9 @@ const MAX_DEBUG_DETAIL_LENGTH = 4000;
  * Truncate debug details to a reasonable size for transport.
  */
 function truncateDebugDetails(details: string): string {
-  if (details.length <= MAX_DEBUG_DETAIL_LENGTH) return details;
+  if (details.length <= MAX_DEBUG_DETAIL_LENGTH) {
+    return details;
+  }
   return details.slice(0, MAX_DEBUG_DETAIL_LENGTH) + "\n… (truncated)";
 }
 
@@ -287,7 +297,7 @@ export function classifyConversationError(
 }
 
 /**
- * Internal throw sites use sentinel pseudo-names (`<llm.default>`,
+ * Internal throw sites use sentinel pseudo-names (`<default>`,
  * `<resolved-callsite>`) when no real connection row is involved; those must
  * not render as literal connection names.
  */
@@ -351,7 +361,9 @@ function classifyCore(
       attribution,
       message,
     });
-    if (c) return c;
+    if (c) {
+      return c;
+    }
   }
 
   // Reason-less (or bad_request/unknown) ProviderError with a status — the
@@ -493,9 +505,13 @@ function extractProviderDetail(message: string): string | undefined {
   detail = detail.replace(/\s*\[[^\]]*\]\s*$/, "").trim();
   if (!detail || detail === message.trim()) {
     // No recognizable prefix — only surface prose that isn't the whole raw line.
-    if (/API error \(\d+\)/i.test(message)) return undefined;
+    if (/API error \(\d+\)/i.test(message)) {
+      return undefined;
+    }
+  }
+  if (!detail) {
+    return undefined;
   }
-  if (!detail) return undefined;
   return detail.length > 200 ? `${detail.slice(0, 200)}…` : detail;
 }
 
@@ -768,19 +784,25 @@ function visionNotSupportedClassification(): Omit<
  * Build a user-facing message that names the exact profile / connection
  * to fix when one is known, falling back to a generic phrase otherwise.
  * Profile is preferred because that's the entity the user picks in the
- * chat picker; connection is shown when no profile is in play (e.g.
- * `llm.default` direct dispatch) or as a parenthetical when both differ.
+ * chat picker; connection is shown when no profile is in play (e.g. the
+ * profileless anchor dispatch) or as a parenthetical when both differ.
  */
 function describeAttribution(
   attribution: ConversationErrorAttribution | undefined,
 ): string {
-  if (!attribution) return "";
+  if (!attribution) {
+    return "";
+  }
   const { profileName, connectionName } = attribution;
   if (profileName && connectionName && profileName !== connectionName) {
     return ` for profile "${profileName}" (connection "${connectionName}")`;
   }
-  if (profileName) return ` for profile "${profileName}"`;
-  if (connectionName) return ` for connection "${connectionName}"`;
+  if (profileName) {
+    return ` for profile "${profileName}"`;
+  }
+  if (connectionName) {
+    return ` for connection "${connectionName}"`;
+  }
   return "";
 }
 

package/src/daemon/conversation-process.ts

@@ -23,6 +23,7 @@ import { extractPreferences } from "../notifications/preference-extractor.js";
 import { createPreference } from "../notifications/preferences-store.js";
 import {
   addMessage,
+  getUserMessageSourceMetadata,
   isHiddenMessageMetadata,
   provenanceFromTrustContext,
   recordConversationPersistedSeq,
@@ -1049,6 +1050,7 @@ async function drainSingleMessage(
     isUserMessage?: boolean;
     titleText?: string;
     isHiddenPrompt?: boolean;
+    messageSource?: string;
   } = { isUserMessage: true };
   if (next.isInteractive !== undefined) {
     drainLoopOptions.isInteractive = next.isInteractive;
@@ -1059,6 +1061,10 @@ async function drainSingleMessage(
   if (isHiddenMessageMetadata(next.metadata)) {
     drainLoopOptions.isHiddenPrompt = true;
   }
+  const queuedMessageSource = getUserMessageSourceMetadata(next.metadata);
+  if (queuedMessageSource !== undefined) {
+    drainLoopOptions.messageSource = queuedMessageSource;
+  }
 
   conversation
     .runAgentLoop(agentLoopContent, userMessageId, {
@@ -1500,6 +1506,7 @@ async function drainBatch(
     isUserMessage?: boolean;
     titleText?: string;
     isHiddenPrompt?: boolean;
+    messageSource?: string;
   } = { isUserMessage: true };
   // Source interactive flag from the last successfully-persisted sibling so
   // a trailing failed tail doesn't flip the agent loop's interactivity.
@@ -1519,6 +1526,21 @@ async function drainBatch(
   ) {
     drainLoopOptions.isHiddenPrompt = true;
   }
+  // Same all-or-nothing rule for the send-source steering: a batch counts
+  // as UI-initiated only when every message in it carries the same source
+  // tag — one hand-typed message justifies a full answer.
+  const batchMessageSource =
+    successfulBatch.length > 0
+      ? getUserMessageSourceMetadata(successfulBatch[0].metadata)
+      : undefined;
+  if (
+    batchMessageSource !== undefined &&
+    successfulBatch.every(
+      (qm) => getUserMessageSourceMetadata(qm.metadata) === batchMessageSource,
+    )
+  ) {
+    drainLoopOptions.messageSource = batchMessageSource;
+  }
 
   // Fire-and-forget: runAgentLoop's finally block recursively calls drainQueue
   // when this run completes. Mirrors drainSingleMessage.

package/src/daemon/conversation-store.ts

@@ -13,6 +13,12 @@
  */
 
 import { getConfig } from "../config/loader.js";
+import {
+  ADOPTABLE_CONVERSATION_ID_RE,
+  createConversation,
+  ensureConversationExists,
+  getConversation,
+} from "../persistence/conversation-crud.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import {
   mainAgentResolutionError,
@@ -157,6 +163,35 @@ export async function getOrCreateConversation(
         },
       );
       newConversation.updateClient(sendToClient, true);
+
+      // Ensure the conversations row exists before hydrating from DB.
+      // `getOrCreateConversation` builds the in-memory Conversation, but
+      // the persisted row is what `loadFromDb` reads for conversationType,
+      // source, and other metadata. If the row doesn't exist yet (brand-new
+      // conversation), create it now so hydration caches the right fields.
+      //
+      // When `conversationType` is provided (e.g. "background" for
+      // plugin-driven conversations), create the row with that type so it
+      // is hidden from the sidebar. The ID is validated against the same
+      // pattern as `ensureConversationExists` to prevent path traversal.
+      // Otherwise use `ensureConversationExists` directly, which validates
+      // and creates a standard row.
+      if (!getConversation(conversationId)) {
+        if (storedOptions?.conversationType) {
+          if (!ADOPTABLE_CONVERSATION_ID_RE.test(conversationId)) {
+            throw new Error(
+              `Refusing to adopt unsafe conversation id: ${JSON.stringify(conversationId)}`,
+            );
+          }
+          createConversation({
+            id: conversationId,
+            conversationType: storedOptions.conversationType,
+          });
+        } else {
+          ensureConversationExists(conversationId);
+        }
+      }
+
       await newConversation.loadFromDb();
       if (storedOptions?.assistantId) {
         newConversation.setAssistantId(storedOptions.assistantId);

package/src/daemon/conversation-surfaces.ts

@@ -11,7 +11,6 @@ import {
   getApp,
   getAppDirPath,
   getAppPreview,
-  isMultifileApp,
   listAppsByConversation,
   resolveAppDir,
   resolveEffectiveAppHtml,
@@ -1825,6 +1824,17 @@ function completeSurfaceFromAction(
   markSurfaceCompleted(ctx, surfaceId, summary);
 }
 
+// One-shot interactive surfaces auto-complete once their action message is
+// accepted (they never accept further actions).
+const ONE_SHOT_SURFACE_TYPES = [
+  "choice",
+  "oauth_connect",
+  "form",
+  "confirmation",
+  "file_upload",
+  "task_preferences",
+];
+
 export async function handleSurfaceAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
@@ -2395,14 +2405,6 @@ export async function handleSurfaceAction(
   // One-shot interactive surfaces — auto-complete now that the message has
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
-  const ONE_SHOT_SURFACE_TYPES = [
-    "choice",
-    "oauth_connect",
-    "form",
-    "confirmation",
-    "file_upload",
-    "task_preferences",
-  ];
   if (
     requestedCompletionSummary ||
     ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)
@@ -3459,22 +3461,20 @@ export async function surfaceProxyResolver(
     const storedPreview = getAppPreview(app.id);
     const { dirName } = resolveAppDir(app.id);
 
-    // For multifile TSX apps, auto-compile if dist is missing, then
-    // resolve HTML from compiled dist/index.html with inlined assets.
-    if (isMultifileApp(app)) {
-      const { existsSync } = await import("node:fs");
-      const { join } = await import("node:path");
-      const appDir = getAppDirPath(app.id);
-      const distIndex = join(appDir, "dist", "index.html");
-      if (!existsSync(distIndex)) {
-        const { compileApp } = await import("../bundler/app-compiler.js");
-        const result = await compileApp(appDir);
-        if (!result.ok) {
-          log.warn(
-            { appId, errors: result.errors },
-            "Auto-compile failed on app_open",
-          );
-        }
+    // Auto-compile if dist is missing, then resolve HTML from compiled
+    // dist/index.html with inlined assets.
+    const { existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const appDir = getAppDirPath(app.id);
+    const distIndex = join(appDir, "dist", "index.html");
+    if (!existsSync(distIndex)) {
+      const { compileApp } = await import("../bundler/app-compiler.js");
+      const result = await compileApp(appDir);
+      if (!result.ok) {
+        log.warn(
+          { appId, errors: result.errors },
+          "Auto-compile failed on app_open",
+        );
       }
     }
     const html = resolveEffectiveAppHtml(app);

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

@@ -16,6 +16,7 @@ import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import { getBindingByConversation } from "../persistence/external-conversation-store.js";
 import { getAllDefaultPluginNames } from "../plugins/defaults/main.js";
+import { isActivationSession } from "../plugins/defaults/memory/activation-session-store.js";
 import { isPluginDisabled } from "../plugins/disabled-state.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
@@ -50,6 +51,10 @@ import {
   type ToolContext,
   type ToolExecutionResult,
 } from "../tools/types.js";
+import {
+  injectActivationMomentParam,
+  projectUiToolsForChannel,
+} from "../tools/ui-surface/channel-variants.js";
 import { loadWorkspaceTools } from "../tools/workspace-tools/loader.js";
 import {
   resolveUsageAttribution,
@@ -194,10 +199,16 @@ export function createToolExecutor(
   const rejectNonAllowlistedTool = (
     toolName: string,
   ): ToolExecutionResult | null => {
+    const allowlist = ctx.subagentAllowedTools;
+    // Record any attempt at a tool outside the subagent's role allowlist — in
+    // both wire and execution gate modes — so the parent can be told what the
+    // subagent needed but lacked. Pure observation; the gating is below.
+    if (allowlist !== undefined && !allowlist.has(toolName)) {
+      ctx.subagentDeniedToolNames?.add(toolName);
+    }
     if (ctx.subagentToolGateMode !== "execution") {
       return null;
     }
-    const allowlist = ctx.subagentAllowedTools;
     if (!allowlist || allowlist.has(toolName)) {
       return null;
     }
@@ -539,7 +550,7 @@ const CROSS_CLIENT_EXPOSED_CAPABILITIES = new Set<HostProxyCapability>([
   "host_browser",
 ]);
 // Tools that require a connected client but no specific host proxy capability.
-const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["app_open", "ask_question"]);
+const CLIENT_CAPABILITY_TOOL_NAMES = new Set(["ask_question"]);
 const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
 
 /**
@@ -822,11 +833,26 @@ export function createResolveToolsCallback(
       ? currentWorkspaceDefs.filter((d) => wireAllowlist.has(d.name))
       : currentWorkspaceDefs;
     const excluded = new Set(getConfig().tools.exclude);
-    const allBaseDefs = [
-      ...scopedCoreDefs,
-      ...scopedWorkspaceDefs,
-      ...scopedMcpDefs,
-    ].filter((d) => !excluded.has(d.name));
+    // Swap UI surface tools for channel-appropriate variants (e.g. Slack's
+    // task_progress-only ui_show). Mirrors the pin handling in
+    // `isToolActiveForContext`: execution-gate-mode wakes pin channel
+    // capabilities to undefined, which resolves to the unprojected defs.
+    const channelForUiTools = ctx.toolContextPin
+      ? undefined
+      : ctx.channelCapabilities?.channel;
+    let allBaseDefs = projectUiToolsForChannel(
+      [...scopedCoreDefs, ...scopedWorkspaceDefs, ...scopedMcpDefs].filter(
+        (d) => !excluded.has(d.name),
+      ),
+      channelForUiTools,
+    );
+    // Activation-rail conversations carry the optional `activation_moment`
+    // telemetry param on ui_show. The marker is written before the first
+    // tool resolution (see `applyBootstrapTemplate` in system-prompt.ts), so
+    // the projected schema is stable for the conversation's lifetime.
+    if (isActivationSession(ctx.conversationId)) {
+      allBaseDefs = injectActivationMomentParam(allBaseDefs);
+    }
 
     const effectivePreactivated = [
       ...DEFAULT_PREACTIVATED_SKILL_IDS,

package/src/daemon/conversation.ts

@@ -34,6 +34,10 @@ import {
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
+import {
+  derefToolResultReReads,
+  postTurnTruncateToolResults,
+} from "../context/post-turn-tool-result-truncation.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
@@ -315,6 +319,14 @@ export class Conversation {
   /** @internal */ toolsDisabledDepth = 0;
   /** @internal */ preactivatedSkillIds?: string[];
   /** @internal */ subagentAllowedTools?: Set<string>;
+  /**
+   * Tool names a subagent attempted but that its role allowlist
+   * ({@link subagentAllowedTools}) denied. Recorded by the tool executor;
+   * surfaced to the parent in the terminal notification so it can re-spawn with
+   * a role that includes them. Ephemeral, never persisted.
+   * @internal
+   */
+  subagentDeniedToolNames = new Set<string>();
   /**
    * How {@link subagentAllowedTools} is enforced — see
    * {@link SubagentToolGateMode}. Set and restored alongside the allowlist
@@ -1258,7 +1270,38 @@ export class Conversation {
         "Repaired persisted history",
       );
     }
-    this.messages = repairedMessages;
+
+    // Recreate the post-turn tool-result view on the reloaded history. Tools
+    // exempt from the result-time spool (file_read/host_file_read, web_fetch)
+    // persist their full oversized content, while the pre-eviction in-memory
+    // history carried the post-turn stubs — so a reload would otherwise feed
+    // the provider the full content those turns already consumed. Re-running
+    // the deterministic finalize passes (deref, then truncate — same order)
+    // restores that byte-identical view (same stub bytes, same
+    // `.tool-results/` paths), keeping the provider prefix cache matching and
+    // the rebuilt context as lean as it was before eviction/restart.
+    // Best-effort like the finalize pass: a failure degrades to full-content
+    // history, never a failed load.
+    let messagesForHistory = repairedMessages;
+    if (conv) {
+      try {
+        messagesForHistory = postTurnTruncateToolResults(
+          derefToolResultReReads(repairedMessages).messages,
+          {
+            conversationDir: getResolvedConversationDirPath(
+              this.conversationId,
+              conv.createdAt,
+            ),
+          },
+        ).messages;
+      } catch (err) {
+        log.warn(
+          { conversationId: this.conversationId, err },
+          "Load-time tool result truncation failed (non-fatal)",
+        );
+      }
+    }
+    this.messages = messagesForHistory;
 
     if (contextSummaryForHistory) {
       this.messages.unshift(
@@ -1465,10 +1508,10 @@ export class Conversation {
    * Mutate the server-authoritative `processing` flag. Web/Capacitor/CLI
    * caches treat this flag as the source of truth for the avatar streaming
    * ring and thinking indicator, so the `true → false` clear must announce
-   * itself: the daemon flips it in the agent-loop `finally` (after an awaited
-   * turn-boundary commit), which is later than the user-visible terminal SSE
-   * events, and a racing metadata refetch can otherwise re-read the
-   * not-yet-cleared `true` and clobber the client's optimistic `false`.
+   * itself: the daemon flips it in the agent-loop `finally`, which runs after
+   * the user-visible terminal SSE events, and a racing metadata refetch can
+   * otherwise re-read the not-yet-cleared `true` and clobber the client's
+   * optimistic `false`.
    *
    * Emitting a metadata invalidation on the clear lets every client GET the
    * authoritative `false`, per the multi-client-sync contract in AGENTS.md
@@ -1976,6 +2019,7 @@ export class Conversation {
       }
       return await this.runCompaction(true, undefined, {
         fixedTailStartIndex: tailIndex,
+        fixedBoundaryRowIndex: boundaryRowIndex,
         // Slack projections gate on the persisted watermark, not on
         // `contextCompactedMessageCount` — without an advance, the summarized
         // rows would reappear verbatim in the projection alongside the new
@@ -2027,6 +2071,8 @@ export class Conversation {
    * `/compact`); without it the manager no-ops below the threshold.
    * `opts.fixedTailStartIndex` pins the kept tail to a caller-chosen history
    * index ("summarize up to here") instead of the token-budget cut;
+   * `opts.fixedBoundaryRowIndex` is the same boundary in row space, which
+   * bounds the compactor's image manifest to rows being summarized away;
    * `opts.fixedBoundarySlackWatermarkTs` is that path's row-space-derived
    * Slack watermark (the auto/forced Slack path derives its own from the
    * chronological projection).
@@ -2036,6 +2082,7 @@ export class Conversation {
     sizing?: CompactionSizing,
     opts?: {
       fixedTailStartIndex?: number;
+      fixedBoundaryRowIndex?: number;
       fixedBoundarySlackWatermarkTs?: string | null;
     },
   ): Promise<ContextWindowResult> {
@@ -2097,6 +2144,7 @@ export class Conversation {
       overrideProfile,
       actorTrustClass: this.trustContext?.trustClass,
       fixedTailStartIndex: opts?.fixedTailStartIndex,
+      fixedBoundaryRowIndex: opts?.fixedBoundaryRowIndex,
     });
     // Track circuit-breaker state for every compaction that ran a summary
     // call — user-initiated `/compact`, other forced paths, and the wake's
@@ -2316,6 +2364,8 @@ export class Conversation {
       titleText?: string;
       /** See {@link runAgentLoopImpl} — hidden machine-signal turn marker. */
       isHiddenPrompt?: boolean;
+      /** See {@link runAgentLoopImpl} — UI-initiated send-source tag. */
+      messageSource?: string;
       callSite?: LLMCallSite;
       /**
        * Optional ad-hoc inference-profile override applied to every LLM call