@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/workspace-migration-140-repair-seed-pinned-memory-v3-live.test.ts

@@ -0,0 +1,330 @@
+/**
+ * Tests for workspace migration `140-repair-seed-pinned-memory-v3-live`.
+ *
+ * The pre-#39847 first-launch seed persisted `memory.v3.live = false` before
+ * migration 105 could record the real decision, stranding brand-new
+ * assistants on v2 and demoting existing v3 assistants whose config.json was
+ * quarantined and reseeded. The repair flips `live` back to true only for
+ * those two victim classes and never over a deliberate opt-out.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairSeedPinnedMemoryV3LiveMigration } from "../workspace/migrations/140-repair-seed-pinned-memory-v3-live.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import type { MigrationRunContext } from "../workspace/migrations/types.js";
+
+const NEW_WORKSPACE_CTX: MigrationRunContext = { isNewWorkspace: true };
+const UPGRADE_CTX: MigrationRunContext = { isNewWorkspace: false };
+
+let workspaceDir: string;
+let configPath: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-140-test-"));
+  configPath = join(workspaceDir, "config.json");
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+function readLive(): unknown {
+  const memory = (readConfig().memory ?? {}) as Record<string, unknown>;
+  const v3 = (memory.v3 ?? {}) as Record<string, unknown>;
+  return v3.live;
+}
+
+function writeConfig(config: Record<string, unknown>): void {
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+/** A checkpoint file whose 105 entry ran `gapMs` after the earliest entry. */
+function writeCheckpoints(gapMs: number): void {
+  const base = Date.parse("2026-06-20T12:00:00.000Z");
+  writeFileSync(
+    join(workspaceDir, "data", ".workspace-migrations.json"),
+    JSON.stringify(
+      {
+        applied: {
+          "001-avatar-rename": {
+            appliedAt: new Date(base).toISOString(),
+            status: "completed",
+          },
+          "105-enable-memory-v3-live-for-new-workspaces": {
+            appliedAt: new Date(base + gapMs).toISOString(),
+            status: "completed",
+          },
+        },
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+}
+
+const FIRST_BOOT_GAP_MS = 5_000;
+const UPGRADE_SWEEP_GAP_MS = 30 * 24 * 60 * 60 * 1000;
+
+function writeSelectionRows(file: string): void {
+  const db = new Database(join(workspaceDir, "data", "db", file));
+  db.exec(`
+    CREATE TABLE memory_v3_selections (
+      conversation_id TEXT NOT NULL,
+      turn INTEGER NOT NULL,
+      slug TEXT NOT NULL,
+      source TEXT NOT NULL,
+      pinned INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT INTO memory_v3_selections (conversation_id, turn, slug, source)
+      VALUES ('conv-1', 1, 'some-page', 'needle');
+  `);
+  db.close();
+}
+
+describe("140-repair-seed-pinned-memory-v3-live migration", () => {
+  test("has correct id and is registered last", () => {
+    expect(repairSeedPinnedMemoryV3LiveMigration.id).toBe(
+      "140-repair-seed-pinned-memory-v3-live",
+    );
+    expect(repairSeedPinnedMemoryV3LiveMigration.description).toContain(
+      "memory.v3.live",
+    );
+    // getLastWorkspaceMigrationId() reports the final entry as the registry
+    // ceiling, so ordering matters: this must be registered, and everything
+    // after it must carry a higher id. Asserting it stays literally last
+    // would break on every migration appended after it.
+    const index = WORKSPACE_MIGRATIONS.findIndex(
+      (migration) => migration.id === "140-repair-seed-pinned-memory-v3-live",
+    );
+    expect(index).toBeGreaterThan(-1);
+    for (const later of WORKSPACE_MIGRATIONS.slice(index + 1)) {
+      expect(later.id > "140").toBe(true);
+    }
+  });
+
+  test("flips a seed-race victim: born in the 105 era, live=false, v3 never ran", () => {
+    writeConfig({
+      memory: { v2: { enabled: true }, v3: { live: false } },
+      llm: { activeProfile: "balanced" },
+    });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+    // The rest of the config is untouched.
+    const config = readConfig();
+    expect((config.llm as Record<string, unknown>).activeProfile).toBe(
+      "balanced",
+    );
+    expect(
+      ((config.memory as Record<string, unknown>).v2 as Record<string, unknown>)
+        .enabled,
+    ).toBe(true);
+  });
+
+  test("skips new workspaces so a hatch-time opt-out override wins", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, NEW_WORKSPACE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("leaves an absent leaf alone: pre-105 assistants stay on the manual-upgrade path", () => {
+    writeConfig({ memory: { v2: { enabled: true } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBeUndefined();
+  });
+
+  test("leaves live=true alone (idempotent after its own repair)", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readLive()).toBe(true);
+    const afterFirstRun = readFileSync(configPath, "utf-8");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readFileSync(configPath, "utf-8")).toBe(afterFirstRun);
+  });
+
+  test("skips a live=false workspace that was NOT born in the 105 era", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("skips when the checkpoint file is missing (no era evidence)", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("respects a hatch-time opt-out recorded in the archived default overlay", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "default-config.json"),
+      JSON.stringify({ memory: { v3: { live: false } } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("an archived overlay without a memory.v3.live opt-out does not block repair", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "default-config.json"),
+      JSON.stringify({ llm: { activeProfile: "balanced" } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("respects a deliberate opt-out: v3 selection rows exist", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeSelectionRows("assistant-memory.db");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("finds selection rows staged under the __relocating name mid-drain", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+    db.exec(`
+      CREATE TABLE memory_v3_selections__relocating (
+        conversation_id TEXT NOT NULL,
+        turn INTEGER NOT NULL,
+        slug TEXT NOT NULL,
+        source TEXT NOT NULL
+      );
+      INSERT INTO memory_v3_selections__relocating
+        (conversation_id, turn, slug, source)
+        VALUES ('conv-1', 1, 'some-page', 'needle');
+    `);
+    db.close();
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("finds selection rows in the pre-relocation assistant.db too", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    writeSelectionRows("assistant.db");
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("an empty selections table is not usage evidence", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(FIRST_BOOT_GAP_MS);
+    const db = new Database(
+      join(workspaceDir, "data", "db", "assistant-memory.db"),
+    );
+    db.exec(
+      `CREATE TABLE memory_v3_selections (conversation_id TEXT, turn INTEGER)`,
+    );
+    db.close();
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("quarantine carry-forward flips a demoted v3 assistant even with usage rows and an old workspace", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeSelectionRows("assistant-memory.db");
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: true } } }, null, 2),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("salvages live=true from a truncated (unparseable) quarantined config", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      `{\n  "memory": {\n    "v3": {\n      "live": true\n    }\n  },\n  "llm": {\n    "activeProf`,
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(true);
+  });
+
+  test("the NEWEST quarantined config wins", () => {
+    writeConfig({ memory: { v3: { live: false } } });
+    writeCheckpoints(UPGRADE_SWEEP_GAP_MS);
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-07-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: true } } }),
+    );
+    writeFileSync(
+      join(workspaceDir, "config.json.corrupt-2026-08-01T10-00-00.000Z.json"),
+      JSON.stringify({ memory: { v3: { live: false } } }),
+    );
+
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+
+    expect(readLive()).toBe(false);
+  });
+
+  test("no-ops when config.json is missing or corrupt", () => {
+    // Missing.
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(existsSync(configPath)).toBe(false);
+
+    // Corrupt.
+    writeFileSync(configPath, "{ not json");
+    repairSeedPinnedMemoryV3LiveMigration.run(workspaceDir, UPGRADE_CTX);
+    expect(readFileSync(configPath, "utf-8")).toBe("{ not json");
+  });
+});

package/src/acp/failure-error.ts

@@ -6,15 +6,13 @@
  * `{"error":{"message":"..."}}`. This picks the most specific signal available:
  * a structured stderr error, else the last stderr line, else the ack message.
  *
- * Pure and dependency-free.
+ * Pure; the only dependency is the shared escape-sequence strip.
  */
 
-// CSI escape sequences (colour codes, cursor moves) that adapters interleave
-// with their log lines: ESC `[`, parameter/intermediate bytes, then final byte.
-const ANSI_ESCAPE = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+import { stripAnsiSequences } from "../util/ansi.js";
 
 export function deriveFailureError(ackMessage: string, stderr: string): string {
-  const clean = stderr.replace(ANSI_ESCAPE, "").trim();
+  const clean = stripAnsiSequences(stderr).trim();
 
   // Most precise: a structured adapter error — prefer it over the ack.
   const jsonMessage = lastJsonErrorMessage(clean);

package/src/agent/attachments.ts

@@ -76,35 +76,37 @@ export function attachmentsToReferenceBlocks(
 
 export function attachmentsToContentBlocks(
   attachments: MessageAttachmentInput[],
-): ContentBlock[] {
-  return attachments.map((attachment) => {
-    if (attachment.mimeType.toLowerCase().startsWith("image/")) {
-      const { data, mediaType } = optimizeImageForTransport(
-        attachment.data,
-        attachment.mimeType,
-      );
+): Promise<ContentBlock[]> {
+  return Promise.all(
+    attachments.map(async (attachment) => {
+      if (attachment.mimeType.toLowerCase().startsWith("image/")) {
+        const { data, mediaType } = await optimizeImageForTransport(
+          attachment.data,
+          attachment.mimeType,
+        );
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: mediaType,
+            data,
+          },
+        } as ContentBlock;
+      }
+
       return {
-        type: "image",
+        type: "file",
         source: {
           type: "base64",
-          media_type: mediaType,
-          data,
+          media_type: attachment.mimeType,
+          data: attachment.data,
+          filename: attachment.filename,
         },
+        extracted_text: attachment.extractedText,
+        ...(attachment.id ? { _attachmentId: attachment.id } : {}),
       } as ContentBlock;
-    }
-
-    return {
-      type: "file",
-      source: {
-        type: "base64",
-        media_type: attachment.mimeType,
-        data: attachment.data,
-        filename: attachment.filename,
-      },
-      extracted_text: attachment.extractedText,
-      ...(attachment.id ? { _attachmentId: attachment.id } : {}),
-    } as ContentBlock;
-  });
+    }),
+  );
 }
 
 /**

package/src/agent/history-repair/history-repair.ts

@@ -15,6 +15,7 @@
  * recover — so detection and repair of ordering drift live together as one unit.
  */
 
+import { analyzeServerToolPairing } from "../../providers/server-tool-pairing.js";
 import type {
   ContentBlock,
   Message,
@@ -69,6 +70,10 @@ export function repairHistory(messages: Message[]): RepairResult {
   let pendingToolUseIds = new Set<string>();
   // tool_result blocks stripped from assistant messages, keyed by tool_use_id
   let recoveredResults = new Map<string, ToolResultContent>();
+  // Server-tool pairs can legitimately span messages (deferred execution) or
+  // sit unanswered at the tail (the provider runs the search on the next
+  // request), so orphanhood is judged against the whole list, not per message.
+  const serverToolPairing = analyzeServerToolPairing(messages);
 
   for (const [msgIndex, msg] of messages.entries()) {
     if (msg.role === "assistant") {
@@ -100,36 +105,32 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Pair server-side tool blocks within the same assistant message.
-      // Server tools (e.g. web_search) emit server_tool_use + matching
-      // web_search_tool_result. Either side can go missing — the synthetic
-      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // Repair orphaned server-side tool blocks. Server tools (e.g.
+      // web_search) emit server_tool_use + matching web_search_tool_result;
+      // orphanhood comes from `serverToolPairing`, which resolves pairs
+      // across messages and exempts the deferred tail. The synthetic result
+      // is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
       // appended to the end) so ensureToolPairing's split at tool_use
       // boundaries cannot separate the pair. An orphan
-      // web_search_tool_result (no preceding server_tool_use) is downgraded
-      // to text — Anthropic rejects the request otherwise.
-      const serverToolIds = new Set(
-        cleanedContent
-          .filter(
-            (b): b is ServerToolUseContent => b.type === "server_tool_use",
-          )
-          .map((b) => b.id),
-      );
-      const matchedServerIds = new Set(
-        cleanedContent
-          .filter((b) => b.type === "web_search_tool_result")
-          .map((b) => (b as { tool_use_id: string }).tool_use_id),
-      );
+      // web_search_tool_result with no use anywhere is downgraded to text.
+      // Anthropic rejects the request otherwise.
       const orphanedServerIds = new Set<string>();
-      for (const id of serverToolIds) {
-        if (!matchedServerIds.has(id)) {
-          orphanedServerIds.add(id);
-        }
-      }
       const orphanedWebSearchResultIds = new Set<string>();
-      for (const id of matchedServerIds) {
-        if (!serverToolIds.has(id)) {
-          orphanedWebSearchResultIds.add(id);
+      for (const b of cleanedContent) {
+        if (b.type === "server_tool_use") {
+          const id = (b as ServerToolUseContent).id;
+          if (
+            !serverToolPairing.resolvedPairIds.has(id) &&
+            !serverToolPairing.deferredUseIds.has(id)
+          ) {
+            orphanedServerIds.add(id);
+          }
+        }
+        if (b.type === "web_search_tool_result") {
+          const id = (b as { tool_use_id: string }).tool_use_id;
+          if (!serverToolPairing.resolvedPairIds.has(id)) {
+            orphanedWebSearchResultIds.add(id);
+          }
         }
       }
 

package/src/agent/image-optimize.ts

@@ -110,10 +110,10 @@ export function upscaleTargetDimensions(dims: {
  * Reactive only: called by the image-recovery plugin after an actual
  * "Could not process image" rejection, never on the pre-send path.
  */
-export function upscaleImageToMinimum(
+export async function upscaleImageToMinimum(
   base64Data: string,
   mediaType: string,
-): { data: string; mediaType: string } | null {
+): Promise<{ data: string; mediaType: string } | null> {
   const dims = parseImageDimensions(base64Data, mediaType);
   if (!dims) {
     return null;
@@ -122,7 +122,7 @@ export function upscaleImageToMinimum(
   if (!target) {
     return null;
   }
-  const upscaled = convertImageToJpeg(Buffer.from(base64Data, "base64"), {
+  const upscaled = await convertImageToJpeg(Buffer.from(base64Data, "base64"), {
     resizeToPx: target,
     quality: JPEG_QUALITY,
   });
@@ -144,10 +144,10 @@ export function upscaleImageToMinimum(
  * Conversion (and its content-addressed disk cache) is shared with attachment
  * storage normalization — see `util/image-conversion.ts`.
  */
-export function optimizeImageForTransport(
+export async function optimizeImageForTransport(
   base64Data: string,
   mediaType: string,
-): { data: string; mediaType: string } {
+): Promise<{ data: string; mediaType: string }> {
   const rawBytes = Buffer.from(base64Data, "base64");
   const dims = parseImageDimensions(base64Data, mediaType);
 
@@ -155,7 +155,7 @@ export function optimizeImageForTransport(
     return { data: base64Data, mediaType };
   }
 
-  const optimized = convertImageToJpeg(rawBytes, {
+  const optimized = await convertImageToJpeg(rawBytes, {
     maxDimensionPx: MAX_DIMENSION,
     quality: JPEG_QUALITY,
   });

package/src/agent/loop.ts

@@ -1,8 +1,8 @@
-import { getConfig } from "../config/loader.js";
-import { isMemoryV3Live } from "../config/memory-v3-gate.js";
+import type { AnsweredQuestion } from "../api/events/question-answered.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
 import { preModelCallSanitize } from "../context/outbound-sanitize.js";
+import { turnStartUserMessageHasSpotlight } from "../context/strip-injections.js";
 import {
   estimatePromptTokensRaw,
   estimatePromptTokensWithTools,
@@ -116,9 +116,9 @@ export interface AgentLoopConfig {
    * This is a SERVER tool the provider runs itself, distinct from the client
    * tool list (`tools` / `resolveTools`): it is never executed by
    * {@link AgentLoopConstructorOptions.toolExecutor} and does not require any
-   * client-tool allowlist entry. Used by the tool-less advisor consult to
-   * ground its guidance with live web access while staying one-shot for client
-   * tools. Defaults to false — existing behavior.
+   * client-tool allowlist entry. Used by the advisor consult to ground its
+   * guidance with live web access on top of its read-only client tools.
+   * Defaults to false.
    */
   enableNativeWebSearch?: boolean;
 }
@@ -289,6 +289,8 @@ export type AgentEvent =
       approvalReason?: string;
       riskThreshold?: string;
       activityMetadata?: ToolActivityMetadata;
+      /** Answered `ask_question` record (see `ToolExecutionResult.answeredQuestion`). */
+      answeredQuestion?: AnsweredQuestion;
       /** Stable machine-readable error classification (see `ToolExecutionResult.errorCode`). */
       errorCode?: string;
       /**
@@ -698,6 +700,7 @@ export type LoopToolExecutor = (
   approvalReason?: string;
   riskThreshold?: string;
   activityMetadata?: ToolActivityMetadata;
+  answeredQuestion?: AnsweredQuestion;
   errorCode?: string;
 }>;
 
@@ -1355,9 +1358,9 @@ export class AgentLoop {
         // `this.provider.supportsNativeWebSearch` snapshot; providers without
         // the routing-aware probe fall back to the static flag. This is a SERVER
         // tool — it bypasses the client allowlist and the tool executor — so the
-        // tool-less advisor consult can ground its guidance with live web access
-        // while staying one-shot for client tools. Skip when a `web_search` tool
-        // is already present so we never duplicate the name.
+        // advisor consult can ground its guidance with live web access on top of
+        // its read-only client tools. Skip when a `web_search` tool is already
+        // present so we never duplicate the name.
         const supportsRoutedNativeWebSearch = this.provider
           .supportsNativeWebSearchFor
           ? this.provider.supportsNativeWebSearchFor(
@@ -1420,9 +1423,7 @@ export class AgentLoop {
         if (this.config.toolChoice) {
           providerConfig.tool_choice = this.config.toolChoice;
         } else if (attachNativeWebSearch) {
-          // The native web-search tool is the only tool on this turn (the
-          // advisor consult is otherwise tool-less). Let the model decide
-          // whether to search rather than forcing it.
+          // Let the model decide whether to search rather than forcing it.
           providerConfig.tool_choice = { type: "auto" };
         }
 
@@ -1430,14 +1431,18 @@ export class AgentLoop {
           providerConfig.cacheTtl = this.config.cacheTtl;
         }
 
-        // Cache-anchor signal for volatile latest-user-message turns: when
-        // memory-v3 is live it injects a per-turn `<memory>` block into the
-        // latest user message, so the provider must anchor its long-TTL cache
-        // breakpoint on the most recent STABLE user message instead of the
-        // volatile latest one. Read here alongside the rest of the provider
-        // config; only set when true so the wire/config stays byte-identical
-        // when off.
-        if (isMemoryV3Live(getConfig())) {
+        // Cache-anchor signal for turns whose opening message is volatile. The
+        // memory-v3 `<memory_spotlight>` block is the only injected block that
+        // is strip-and-replaced from every user message each turn, so when it
+        // is present that message's bytes do not recur next turn and a
+        // long-TTL breakpoint on it could never be read back. The provider
+        // marks it at the short TTL instead. Derived from the history actually
+        // being sent rather than from configuration, so turns where memory
+        // contributed no spotlight keep a normal anchor. Read off the
+        // turn-starting message, so the signal holds for every request in the
+        // turn rather than flipping once tool results arrive. Only set when
+        // true so the wire/config stays byte-identical when absent.
+        if (turnStartUserMessageHasSpotlight(history)) {
           providerConfig.mutableLatestUserMessage = true;
         }
 
@@ -1459,8 +1464,17 @@ export class AgentLoop {
           // conversation id). Absent for standalone `AgentLoop` instances
           // (unit tests constructed without a conversation id) — those fall
           // back to per-call random mix selection.
+          //
+          // The same id also travels as `conversationId`, which
+          // `RetryProvider.normalizeSendMessageOptions` uses to resolve the
+          // conversation's subagent role and spawn mode for the runtime
+          // proxy's billing-attribution headers. Both are stripped before any
+          // provider wire request; they are carried separately because
+          // `selectionSeed` is an opaque hashing input that callers may set to
+          // something other than a conversation id.
           if (this.conversationId) {
             providerConfig.selectionSeed = this.conversationId;
+            providerConfig.conversationId = this.conversationId;
           }
         }
 
@@ -2201,13 +2215,16 @@ export class AgentLoop {
         // message between calls would invalidate the prompt-cache prefix on
         // every iteration).
         if (conversationDir) {
-          const toolNameByUseId = new Map(
-            toolUseBlocks.map((tu) => [tu.id, tu.name]),
+          const toolCallByUseId = new Map(
+            toolUseBlocks.map((tu) => [
+              tu.id,
+              { name: tu.name, input: tu.input },
+            ]),
           );
           try {
             spoolAndStubOversizedToolResults(rawResultBlocks, {
               conversationDir,
-              toolNameById: (id) => toolNameByUseId.get(id),
+              toolCallById: (id) => toolCallByUseId.get(id),
             });
           } catch (err) {
             rlog.warn(
@@ -2286,6 +2303,7 @@ export class AgentLoop {
             approvalReason: result.approvalReason,
             riskThreshold: result.riskThreshold,
             activityMetadata: result.activityMetadata,
+            answeredQuestion: result.answeredQuestion,
             errorCode: result.errorCode,
           });
         }