@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/contacts/mirror-tombstones.ts

@@ -0,0 +1,42 @@
+/**
+ * Short-lived tombstones for deleted mirror contacts.
+ *
+ * The mirror reconciler pulls a gateway identity snapshot and then applies it;
+ * a contact deleted (or merged away) while that pull is in flight would be
+ * resurrected from the stale snapshot, and the reconciler's additive contract
+ * (it never deletes) would keep the ghost forever. Recording each deletion
+ * here lets the reconciler refuse to heal an id that died after the snapshot
+ * was taken.
+ *
+ * Contact ids are UUIDs and never come back, so a tombstone can never block
+ * a legitimate recreation; the TTL only bounds memory.
+ */
+
+/** Generously longer than a snapshot pull plus its debounced follow-up. */
+const TOMBSTONE_TTL_MS = 15 * 60 * 1000;
+
+const tombstones = new Map<string, number>();
+
+/** Record that the mirror contact row for `contactId` was deleted. */
+export function recordContactTombstone(contactId: string): void {
+  const now = Date.now();
+  tombstones.set(contactId, now + TOMBSTONE_TTL_MS);
+  for (const [id, expiresAt] of tombstones) {
+    if (expiresAt <= now) {
+      tombstones.delete(id);
+    }
+  }
+}
+
+/** Whether `contactId` was deleted recently enough that a snapshot may predate it. */
+export function isContactTombstoned(contactId: string): boolean {
+  const expiresAt = tombstones.get(contactId);
+  if (expiresAt === undefined) {
+    return false;
+  }
+  if (expiresAt <= Date.now()) {
+    tombstones.delete(contactId);
+    return false;
+  }
+  return true;
+}

package/src/contacts/notify-contacts-changed.ts

@@ -7,14 +7,23 @@ import { invalidateGuardianDeliveryCache } from "./guardian-delivery-reader.js";
  * Notify everything that cares about a contact mutation. Called directly after
  * a successful contact write:
  *
- * - broadcasts `contacts_changed` so connected clients refresh their view, and
+ * - broadcasts `contacts_changed` so connected clients refresh their view,
  * - drops the guardian-contact, guardian-delivery, and contact-threshold
  *   caches so the next read refetches from the gateway instead of serving
- *   a stale set.
+ *   a stale set, and
+ * - asks the mirror reconciler for a debounced convergence pass, so identity
+ *   drift the per-write mirror ops missed heals on the next contact activity.
+ *
+ * The reconciler is reached via dynamic import: it applies its heals through
+ * the contact-store primitives, whose writes land back here, and a static
+ * import would close that cycle at module-load time.
  */
 export function notifyContactsChanged(): void {
   broadcastMessage({ type: "contacts_changed" });
   invalidateGuardianContactCache();
   invalidateGuardianDeliveryCache();
   invalidateAllContactThresholdCaches();
+  void import("./mirror-reconciler.js")
+    .then((m) => m.scheduleMirrorReconcile())
+    .catch(() => {});
 }

package/src/context/compactor.ts

@@ -64,17 +64,31 @@ const log = getLogger("compactor");
 const COMPACTION_CALL_SITE: LLMCallSite = "mainAgent";
 
 /**
- * Tag stamped on `llm_request_logs.call_site` for compaction-driven rows.
+ * Tag stamped on `llm_request_logs.call_site` and the usage event's
+ * `callSite` for compaction-driven rows.
  *
  * Distinct from `COMPACTION_CALL_SITE` (above) on purpose: that constant
- * names the **provider config resolution** site (set to `mainAgent` so we
+ * names the provider-config resolution site (set to `mainAgent` so we
  * inherit the agent's profile and keep the prefix cache warm). This
- * constant names the **observability** site — what the row IS — so
- * inspectors can filter "show me only compaction calls". They're
+ * constant names the observability site (what the row is) so
+ * inspectors and usage breakdowns can filter compaction calls. They're
  * semantically different even though both come from the same enum.
  */
 const COMPACTION_LOG_CALL_SITE: LLMCallSite = "compactionAgent";
 
+function compactionUsageAttribution(
+  args: Pick<CompactionRunArgs, "overrideProfile">,
+): Pick<
+  CompactionRunResult,
+  "summaryCallSite" | "summaryResolutionCallSite" | "summaryOverrideProfile"
+> {
+  return {
+    summaryCallSite: COMPACTION_LOG_CALL_SITE,
+    summaryResolutionCallSite: COMPACTION_CALL_SITE,
+    summaryOverrideProfile: args.overrideProfile ?? null,
+  };
+}
+
 /**
  * What actually served a compaction call, for attribution on both the request
  * log and the usage row. A wrapper may reroute the request away from the
@@ -354,6 +368,14 @@ export interface CompactionRunResult {
   summaryOutputTokens: number;
   summaryModel: string;
   summaryCallSite?: LLMCallSite;
+  /**
+   * Call site used to resolve the winning inference profile for the
+   * summary. Compaction invokes the provider as `mainAgent` so the
+   * prefix cache stays warm; {@link summaryCallSite} is the observability
+   * tag (`compactionAgent`). Attribution uses this field for profile
+   * selection and {@link summaryCallSite} for the usage-row call site.
+   */
+  summaryResolutionCallSite?: LLMCallSite;
   summaryOverrideProfile?: string | null;
   /**
    * Provider that actually served the summary call: the response's
@@ -977,6 +999,18 @@ export async function buildRetainedImageBlocks(
         media_type: optimized.mediaType,
         data: optimized.data,
       },
+      // The rebuilt block is inline bytes, so the row it came from is only
+      // recoverable from the id the manifest entry already holds. Carrying it
+      // keeps a retained image traceable to its attachment, which is what
+      // camera-frame retention matches on: without it a frame the compaction
+      // model chose to keep would be invisible to every later pass and could
+      // outlive the retention bound.
+      //
+      // Assigned rather than spread through `attachmentIdFragment`, the helper
+      // the conditional producers share: a manifest entry always names a row,
+      // so making the field conditional here would describe an absence the
+      // type rules out.
+      _attachmentId: entry.attachmentId,
     });
     resolved.push(name);
   }
@@ -1406,8 +1440,7 @@ export async function runAssistantDrivenCompaction(
       summaryCacheCreationInputTokens:
         response.usage.cacheCreationInputTokens ?? 0,
       summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
-      summaryCallSite: COMPACTION_CALL_SITE,
-      summaryOverrideProfile: args.overrideProfile ?? null,
+      ...compactionUsageAttribution(args),
       summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
       summaryRequestLogId,
       summaryCalls: 1,
@@ -1445,8 +1478,7 @@ export async function runAssistantDrivenCompaction(
         summaryCacheCreationInputTokens:
           response.usage.cacheCreationInputTokens ?? 0,
         summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
-        summaryCallSite: COMPACTION_CALL_SITE,
-        summaryOverrideProfile: args.overrideProfile ?? null,
+        ...compactionUsageAttribution(args),
         summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
         summaryCalls: 1,
       };
@@ -1616,8 +1648,7 @@ export async function runAssistantDrivenCompaction(
       summaryCacheCreationInputTokens:
         response.usage.cacheCreationInputTokens ?? 0,
       summaryCacheReadInputTokens: response.usage.cacheReadInputTokens ?? 0,
-      summaryCallSite: COMPACTION_CALL_SITE,
-      summaryOverrideProfile: args.overrideProfile ?? null,
+      ...compactionUsageAttribution(args),
       summaryRawResponses: response.rawResponse ? [response.rawResponse] : [],
       summaryRequestLogId,
       summaryCalls: 1,
@@ -1686,8 +1717,7 @@ export async function runAssistantDrivenCompaction(
     summaryInputTokens: response.usage.inputTokens,
     summaryOutputTokens: response.usage.outputTokens,
     summaryModel: response.model,
-    summaryCallSite: COMPACTION_CALL_SITE,
-    summaryOverrideProfile: args.overrideProfile ?? null,
+    ...compactionUsageAttribution(args),
     ...servedAttribution(response, args.provider),
     summaryCacheCreationInputTokens:
       response.usage.cacheCreationInputTokens ?? 0,
@@ -1874,12 +1904,11 @@ export async function runEmergencyCompaction(
       summaryInputTokens: response.usage.inputTokens,
       summaryOutputTokens: response.usage.outputTokens,
       summaryModel: response.model,
-      // This path bills real tokens, so its provider must follow a reroute
-      // like every other call-bearing path. It is the one such path that sets
-      // no `summaryCallSite`/`summaryOverrideProfile`, which leaves its
-      // profile attribution null; that gap predates this change and is not
-      // widened by it.
+      // This path bills real tokens, so its provider, call site, and
+      // override profile must follow the same attribution as every other
+      // call-bearing compaction path.
       ...servedAttribution(response, args.provider),
+      ...compactionUsageAttribution(args),
     };
   }
 
@@ -1925,8 +1954,7 @@ export async function runEmergencyCompaction(
     summaryInputTokens: response.usage.inputTokens,
     summaryOutputTokens: response.usage.outputTokens,
     summaryModel: response.model,
-    summaryCallSite: COMPACTION_CALL_SITE,
-    summaryOverrideProfile: args.overrideProfile ?? null,
+    ...compactionUsageAttribution(args),
     ...servedAttribution(response, args.provider),
     summaryCacheCreationInputTokens:
       response.usage.cacheCreationInputTokens ?? 0,

package/src/context/tool-result-spool.ts

@@ -20,15 +20,22 @@ const AX_TREE_TAG = "<ax-tree>";
 
 /**
  * Tools whose results are explicit, self-sized reads the model paginates
- * itself: `web_fetch` takes `max_chars`/`start_index` and reports a
- * "Character Window: X-Y of Z", so the model pages by character index against
- * the window it requested. Stubbing such a result at result time hands the
- * model ~a tenth of the window it just sized — and it keeps paging blind
- * against content it never saw. Like the file-read tools, these explicit
- * reads are honored in full for the turn that made them; the post-turn pass
- * still truncates them at turn end, after the model has consumed the content.
+ * itself: each takes `max_chars`/`start_index` and reports where its window
+ * ended (`web_fetch`'s "Character Window: X-Y of Z", the file-read tools'
+ * "[Truncated: characters X-Y of Z]" notice), so the model pages by character
+ * index against the window it requested. Stubbing such a result at result
+ * time would hand the model a fraction of the window it just sized — and it
+ * keeps paging blind against content it never saw. These reads are honored in
+ * full for the turn that made them; the post-turn pass still truncates them
+ * at turn end, after the model has consumed the content. This exemption is
+ * also what lets `READ_CHAR_BUDGET` exceed `THRESHOLD_CHARS` without a fresh
+ * read being stubbed before the model sees it.
  */
-export const RESULT_TIME_SPOOL_EXEMPT_TOOLS = new Set<string>(["web_fetch"]);
+export const RESULT_TIME_SPOOL_EXEMPT_TOOLS = new Set<string>([
+  "web_fetch",
+  "file_read",
+  "host_file_read",
+]);
 
 /**
  * Whether a tool result is eligible for the result-time spool/stub pass: the
@@ -39,12 +46,12 @@ export const RESULT_TIME_SPOOL_EXEMPT_TOOLS = new Set<string>(["web_fetch"]);
  * The spooled-read exemption is what keeps paging possible: a file read is the
  * model's only way to pull spooled content back into context, so stubbing a
  * read of a `.tool-results/` file would write a fresh copy and hand back
- * another stub, putting that content out of reach for good. It is scoped by
- * target path rather than by tool name, because a file read aimed anywhere
- * else is ordinary oversized output with no such circularity, and exempting it
- * keeps a whole file inline on every LLM call for the rest of the turn.
- * Explicit self-sized reads are honored in full; the post-turn pass still
- * truncates them at turn end, after the model has consumed the content.
+ * another stub, putting that content out of reach for good. The file-read
+ * tools are also name-exempt as explicit self-sized reads, but this
+ * path-scoped guarantee stands on its own so spooled content stays reachable
+ * regardless of how the exempt-tools set evolves. Explicit self-sized reads
+ * are honored in full; the post-turn pass still truncates them at turn end,
+ * after the model has consumed the content.
  */
 function isSpoolEligible(
   tr: ToolResultContent,

package/src/conversations/message-consolidation.ts

@@ -39,8 +39,8 @@ import { getLogger } from "../util/logger.js";
 const log = getLogger("message-consolidation");
 
 /**
- * True when an assistant row is a standalone display turn (system card or
- * provider-error notice) that never merges with adjacent assistant rows in
+ * True when an assistant row is a standalone display turn (system card,
+ * provider-error notice, or deliberate-silence marker) that never merges with adjacent assistant rows in
  * either direction. Merging one into an adjacent run would let the anchor's
  * metadata win and drop the `messageKind` marker from the wire (or stamp it
  * onto a bubble containing real assistant text).

package/src/credential-health/credential-health-service.ts

@@ -4,9 +4,19 @@
  * Enumerates all active OAuth connections and validates each one for:
  * - Token presence in secure storage
  * - Token expiry (expired or expiring within the warning window)
- * - Scope coverage (grantedScopes vs provider defaultScopes)
+ * - Scope coverage (grantedScopes vs the request that produced the token)
  * - Liveness ping (for providers with a pingUrl)
  *
+ * Scope coverage asks whether a connection carries the scopes the provider
+ * currently requests for the token it stores, which is how a newly required
+ * scope reaches an existing install and prompts a re-authorization. It applies
+ * only where an authorization makes a request. A manual-token provider (a bot
+ * token pasted in, e.g. `slack_channel`) has no request and carries empty
+ * scope lists here; it is still checked for token presence and liveness. What
+ * its token actually carries is read live from the `x-oauth-scopes` response
+ * header by `runtime/channel-readiness-service.ts`, which is the only source
+ * of truth available for a credential this service never negotiated.
+ *
  * Designed to run during the heartbeat cycle. The BYO liveness ping is
  * routed through `withValidToken`, so a stale-but-refreshable access token
  * is refreshed transparently before the ping fires — this prevents the
@@ -24,7 +34,10 @@ import {
   type OAuthConnectionRow,
   type OAuthProviderRow,
 } from "../oauth/oauth-store.js";
-import { scopeDifference } from "../oauth/scope-utils.js";
+import {
+  expectedScopesForStoredToken,
+  scopeDifference,
+} from "../oauth/scope-utils.js";
 import {
   TokenExpiredError,
   withValidToken,
@@ -182,6 +195,8 @@ interface CheckConnectionOpts {
   hasRefreshToken: boolean;
   grantedScopesRaw: string;
   defaultScopesRaw: string;
+  authorizeParamsRaw: string | null;
+  scopeSeparator: string | null;
   pingUrl: string | null;
   pingMethod: string | null;
   pingHeaders: string | null;
@@ -199,6 +214,8 @@ async function checkConnection(
     hasRefreshToken,
     grantedScopesRaw,
     defaultScopesRaw,
+    authorizeParamsRaw,
+    scopeSeparator,
     pingUrl,
     pingMethod,
     pingHeaders,
@@ -268,11 +285,21 @@ async function checkConnection(
     // Has refresh token — not an issue, auto-refresh will handle it
   }
 
-  // 3. Check scope coverage
+  // 3. Check scope coverage, against the request that produced the stored
+  // token rather than the provider's bot-side `scope` parameter. A provider
+  // asking for user scopes as well stores the user token and records that
+  // token's grant, so the bot request names scopes that grant can never hold.
   const grantedScopes = safeJsonParse<string[]>(grantedScopesRaw, []);
-  const defaultScopes = safeJsonParse<string[]>(defaultScopesRaw, []);
-  if (defaultScopes.length > 0 && grantedScopes.length > 0) {
-    const missing = scopeDifference(defaultScopes, grantedScopes);
+  const expectedScopes = expectedScopesForStoredToken(
+    safeJsonParse<string[]>(defaultScopesRaw, []),
+    safeJsonParse<Record<string, string> | undefined>(
+      authorizeParamsRaw,
+      undefined,
+    ),
+    scopeSeparator ?? undefined,
+  );
+  if (expectedScopes.length > 0 && grantedScopes.length > 0) {
+    const missing = scopeDifference(expectedScopes, grantedScopes);
     if (missing.length > 0) {
       return {
         ...base,
@@ -637,6 +664,8 @@ export async function checkAllCredentials(): Promise<CredentialHealthReport> {
           hasRefreshToken: !!conn.hasRefreshToken,
           grantedScopesRaw: conn.grantedScopes,
           defaultScopesRaw: providerRow.defaultScopes,
+          authorizeParamsRaw: providerRow.authorizeParams,
+          scopeSeparator: providerRow.scopeSeparator,
           pingUrl: providerRow.pingUrl,
           pingMethod: providerRow.pingMethod,
           pingHeaders: providerRow.pingHeaders,
@@ -750,6 +779,8 @@ export async function checkCredentialForProvider(
       hasRefreshToken: !!conn.hasRefreshToken,
       grantedScopesRaw: conn.grantedScopes,
       defaultScopesRaw: providerRow.defaultScopes,
+      authorizeParamsRaw: providerRow.authorizeParams,
+      scopeSeparator: providerRow.scopeSeparator,
       pingUrl: providerRow.pingUrl,
       pingMethod: providerRow.pingMethod,
       pingHeaders: providerRow.pingHeaders,

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

@@ -22,6 +22,7 @@ import { getConfig } from "../config/loader.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
 import { stripInjectionsForCompaction } from "../context/strip-injections.js";
 import { getCalibrationProviderKey } from "../context/token-estimator.js";
+import type { ProviderMessageMetadata } from "../messaging/provider-message-metadata.js";
 import {
   formatSlackTimezoneLabel,
   isSlackTs,
@@ -1399,6 +1400,22 @@ function buildAssistantChannelMetadata(
         partialSlackMeta as SlackMessageMetadata,
       );
     }
+  } else if (deps.turnChannelContext.assistantMessageChannel !== "vellum") {
+    // Every other channel row describes itself in the neutral envelope
+    // `readProviderMetadata` serves, the shape a plugin channel writes too.
+    // `messageId` stays absent here and is back-filled by the post-send
+    // reconciliation once the transport returns the sent message's id, which
+    // is what lets a later reaction on this row resolve back to it. No
+    // `threadId`: a value there asserts a thread exists, and the reply's
+    // routing thread is delivery state, not a fact about this row.
+    const chatId = turnOrRestingTrust(deps.ctx)?.requesterChatId;
+    if (chatId) {
+      metadata.providerMeta = JSON.stringify({
+        source: deps.turnChannelContext.assistantMessageChannel,
+        conversationExternalId: chatId,
+        eventKind: "message",
+      } satisfies ProviderMessageMetadata);
+    }
   }
 
   return metadata;
@@ -3163,7 +3180,7 @@ function handleUsage(
         JSON.stringify(event.rawResponse),
         undefined,
         providerName,
-        "mainAgent",
+        deps.ctx.currentCallSite,
         latencyBreakdownJson,
       );
     } catch (err) {
@@ -3244,7 +3261,7 @@ function handleProviderError(
       JSON.stringify(buildProviderErrorResponsePayload(event.error)),
       undefined,
       event.actualProvider,
-      "mainAgent",
+      deps.ctx.currentCallSite,
     );
   } catch (err) {
     deps.rlog.warn(

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

@@ -51,8 +51,10 @@ import {
   resolveOverrideProfile,
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
+  updateMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import { isReplaceableTitle } from "../persistence/conversation-title-service.js";
+import { NO_RESPONSE_MESSAGE_KIND } from "../persistence/conversation-types.js";
 import {
   backfillMessageIdOnLogs,
   recordSyntheticAgentErrorMessageLog,
@@ -73,6 +75,7 @@ import {
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
+import { isNoResponseOnlyText } from "../runtime/no-response.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { stampTurnOutcome } from "../telemetry/turn-outcome.js";
 import {
@@ -113,6 +116,7 @@ import {
   drainConversationNotices,
 } from "./conversation-notices.js";
 import {
+  applySightFrameRetention,
   getSlackCompactionWatermarkForPrefix,
   loadSlackChronologicalContext,
   resolveTurnInboundActorContext,
@@ -133,6 +137,10 @@ import {
   unregisterInflightTurn,
 } from "./inflight-turn-registry.js";
 import type { UsageStats } from "./message-protocol.js";
+import {
+  persistReactionRecords,
+  type QueuedReactionRecord,
+} from "./reaction-record.js";
 import type { TrustContext } from "./trust-context-types.js";
 import { turnOrRestingTrust } from "./trust-context-types.js";
 import { resolveTurnCallSite } from "./turn-call-site.js";
@@ -775,6 +783,14 @@ export async function runAgentLoopImpl(
   // turn's content is settled; the `finally` calls it again as the backstop for
   // the cancel/error paths that never reached the early release.
   let turnReleased = false;
+  // The turn's own queued reaction records, captured by `releaseTurn` while
+  // the conversation is still exclusive. The `finally` drains this array,
+  // never the live conversation field: after release a following turn may
+  // queue records of its own there, and draining the shared field would
+  // consume the new turn's record before its tool_result settles, the
+  // cross-turn variant of the pairing corruption the boundary drain
+  // prevents.
+  const ownedReactionRecords: QueuedReactionRecord[] = [];
 
   /**
    * Free the conversation for its next turn.
@@ -814,6 +830,11 @@ export async function runAgentLoopImpl(
         );
       }
     }
+    // Ownership capture happens in the same synchronous step as the
+    // release, so records queued after this point belong to the next turn.
+    if (ctx.pendingReactionRecords?.length) {
+      ownedReactionRecords.push(...ctx.pendingReactionRecords.splice(0));
+    }
     ctx.abortController = null;
     ctx.setProcessing(false);
     unregisterInflightTurn(ctx.conversationId, state);
@@ -1255,10 +1276,22 @@ export async function runAgentLoopImpl(
     // immediately before the call, after every hook (memory injection, title,
     // user plugins) has settled its shape. Runs unconditionally — a malformed
     // history is a hard provider rejection, never a per-conversation opt-in.
-    const runMessages = repairHistoryForRun(
+    const repairedMessages = repairHistoryForRun(
       finalUserPromptCtx.latestMessages,
       ctx.conversationId,
     );
+    // Camera-frame retention: keep only the newest few ambient frames as real
+    // images. Applied to the per-turn copy, after every hook and the repair, so
+    // every turn this loop drives inherits it and the stored transcript keeps
+    // its attachments. The loop re-runs the same pass on any history its
+    // in-place compaction rebuilds (see the `transformCompactedHistory` closure
+    // the conversation supplies), so the bound holds across a compaction rather
+    // than only from the next turn. The overflow ladder's media stubbing still
+    // governs everything the user deliberately attached.
+    const runMessages = applySightFrameRetention(
+      repairedMessages,
+      ctx.conversationId,
+    );
 
     // 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.
@@ -1563,6 +1596,32 @@ export async function runAgentLoopImpl(
     // of why the turn stopped.
     const hasAssistantResponse =
       newMessages[newMessages.length - 1]?.role === "assistant";
+    // A reply that is nothing but the `<no_response/>` sentinel is deliberate
+    // silence. Stamp the persisted row so clients render a quiet notice and
+    // resolve their pending-response state, instead of showing the raw
+    // sentinel or waiting forever; the content keeps the sentinel so the
+    // model reads its own convention back from history.
+    if (hasAssistantResponse && state.lastAssistantMessageId) {
+      const tail = newMessages[newMessages.length - 1]!;
+      const tailText = Array.isArray(tail.content)
+        ? tail.content
+            .filter((b) => b.type === "text")
+            .map((b) => (b.type === "text" ? b.text : ""))
+            .join("\n")
+        : "";
+      if (isNoResponseOnlyText(tailText)) {
+        try {
+          updateMessageMetadata(state.lastAssistantMessageId, {
+            messageKind: NO_RESPONSE_MESSAGE_KIND,
+          });
+        } catch (err) {
+          rlog.warn(
+            { err, messageId: state.lastAssistantMessageId },
+            "Failed to stamp deliberate-silence marker (non-fatal)",
+          );
+        }
+      }
+    }
     if (
       !hasAssistantResponse &&
       state.providerErrorUserMessage &&
@@ -1998,6 +2057,16 @@ export async function runAgentLoopImpl(
       // the API, enabling stable prefix caching across turns.  Compaction
       // consolidates when it summarizes old messages (cache miss is expected).
     } finally {
+      // Backstop for paths that threw before either release site: still
+      // exclusive here, so the release's ownership capture is race-free.
+      releaseTurn();
+      // Reactions the turn delivered get their durable rows on every
+      // terminal path, error exits included: the reaction already happened
+      // on the channel, and the record must not depend on the turn
+      // finishing cleanly. Only records this turn captured at release are
+      // drained; writing after the turn stops producing rows keeps them out
+      // of any tool_use/tool_result pair.
+      await drainQueuedReactionRecords(ctx, ownedReactionRecords);
       // kickDrainQueue never rejects: a drain failure here would otherwise be
       // an unhandled rejection that strands the queue with nothing left to
       // re-trigger it.
@@ -2009,6 +2078,32 @@ export async function runAgentLoopImpl(
   }
 }
 
+/**
+ * Persist and clear the turn's queued reaction records. Non-throwing: a
+ * failure here must never mask the turn's own outcome, and
+ * `persistReactionRecords` already logs per-record failures.
+ */
+export async function drainQueuedReactionRecords(
+  ctx: Pick<Conversation, "conversationId" | "markHistoryStale">,
+  ownedRecords: QueuedReactionRecord[] | undefined,
+): Promise<void> {
+  // Runs inside the loop's finally, where a throw would mask the turn's own
+  // outcome, so every access sits inside the guard. Drains only the records
+  // the finished turn captured at release, never the conversation's live
+  // queue, so one turn cannot consume a following turn's records.
+  try {
+    if (!ownedRecords?.length) {
+      return;
+    }
+    const queuedReactions = ownedRecords.splice(0);
+    await persistReactionRecords(ctx.conversationId, queuedReactions);
+    ctx.markHistoryStale();
+  } catch {
+    // persistReactionRecords is itself non-throwing per record; this guard
+    // covers only unexpected faults so the finally block stays safe.
+  }
+}
+
 // ── Helper ───────────────────────────────────────────────────────────
 
 function emitUsage(
@@ -2110,6 +2205,7 @@ export async function applyCompactionResult(
     summaryCacheReadInputTokens?: number;
     summaryRawResponses?: unknown[];
     summaryCallSite?: LLMCallSite;
+    summaryResolutionCallSite?: LLMCallSite;
     summaryOverrideProfile?: string | null;
     summaryActualProvider?: string;
     summaryActualInferenceProfile?: string;
@@ -2200,6 +2296,9 @@ export async function applyCompactionResult(
     // this parameter independently off their own state and never share it.
     {
       callSite: result.summaryCallSite ?? null,
+      ...(result.summaryResolutionCallSite != null
+        ? { profileResolutionCallSite: result.summaryResolutionCallSite }
+        : {}),
       overrideProfile:
         result.summaryActualInferenceProfile ??
         result.summaryOverrideProfile ??

package/src/daemon/conversation-media-retry.ts

@@ -4,11 +4,17 @@
  * When the provider rejects a request because the context is too large,
  * this module replaces older image and file content blocks with lightweight
  * text stubs to shrink the payload before retrying.
+ *
+ * The proactive counterpart, applied on every assembly and only to ambient
+ * camera frames, is `stripAgedSightFrames` in `conversation-sight-frames.ts`.
+ * Both paths name what they dropped through `mediaSourceDescriptor`, so the
+ * stubs describe media identically. A block that path already stubbed is plain
+ * text here, so it is neither counted as media nor stubbed twice.
  */
 
 import { estimateContentBlockTokens } from "../context/token-estimator.js";
 import { getSummaryFromContextMessage } from "../plugins/defaults/compaction/window-manager.js";
-import { mediaSourceByteLength } from "../providers/media-resolve.js";
+import { mediaSourceDescriptor } from "../providers/media-resolve.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 export interface StripMediaOptions {
@@ -219,17 +225,16 @@ export function estimateUnconditionalStubTokens(
 function imageBlockToStub(
   block: Extract<ContentBlock, { type: "image" }>,
 ): Extract<ContentBlock, { type: "text" }> {
-  const sizeBytes = mediaSourceByteLength(block.source);
   return {
     type: "text",
-    text: `[Image omitted from retry context: ${block.source.media_type}, ${sizeBytes} bytes]`,
+    text: `[Image omitted from retry context: ${mediaSourceDescriptor(block.source)}]`,
   };
 }
 
 function fileBlockToStub(
   block: Extract<ContentBlock, { type: "file" }>,
 ): Extract<ContentBlock, { type: "text" }> {
-  const sizeBytes = mediaSourceByteLength(block.source);
+  const descriptor = mediaSourceDescriptor(block.source);
   const extracted = (block.extracted_text ?? "").trim();
   const preview =
     extracted.length > MAX_MEDIA_STUB_TEXT
@@ -239,8 +244,8 @@ function fileBlockToStub(
     type: "text",
     text:
       preview.length > 0
-        ? `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]\n${preview}`
-        : `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]`,
+        ? `[File omitted from retry context: ${block.source.filename} (${descriptor})]\n${preview}`
+        : `[File omitted from retry context: ${block.source.filename} (${descriptor})]`,
   };
 }