@vellumai/assistant 0.8.4 → 0.8.5

package/src/memory/conversation-starters-cadence.ts

@@ -9,7 +9,7 @@ import { and, eq, inArray, sql } from "drizzle-orm";
 
 import { getLogger } from "../util/logger.js";
 import { getDb } from "./db-connection.js";
-import { enqueueMemoryJob } from "./jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "./jobs-store.js";
 import { rawGet } from "./raw-query.js";
 import { memoryCheckpoints, memoryJobs } from "./schema.js";
 
@@ -20,6 +20,8 @@ const log = getLogger("conversation-starters-cadence");
  * generating a fresh batch of conversation starters.
  */
 export function maybeEnqueueConversationStartersJob(scopeId: string): void {
+  if (!isMemoryEnabled()) return;
+
   const db = getDb();
 
   // Count total active memory items

package/src/memory/conversation-title-service.ts

@@ -331,10 +331,10 @@ function buildTitlePrompt(
   }
 
   if (userMessage) {
-    parts.push(`User: ${userMessage}`);
+    parts.push(`User: ${stripThinkingTags(userMessage)}`);
   }
   if (assistantResponse) {
-    parts.push(`Assistant: ${assistantResponse}`);
+    parts.push(`Assistant: ${stripThinkingTags(assistantResponse)}`);
   }
 
   return parts.join("\n");
@@ -378,12 +378,28 @@ function truncateTitle(title: string): string {
 function normalizeTitle(raw: string): string {
   let title = raw.trim().replace(/^["']|["']$/g, "");
   title = stripMarkdown(title);
+  title = stripThinkingTags(title);
   if (META_FAILURE_TITLES.has(title.toLowerCase())) {
     return "";
   }
   return truncateTitle(title);
 }
 
+/** Strip thinking tags so they don't bleed into generated titles. */
+function stripThinkingTags(text: string): string {
+  return text
+    .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "")
+    .replace(/<thought>[\s\S]*?<\/thought>/gi, "")
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<thought>/gi, "")
+    .replace(/<\/thought>/gi, "")
+    .replace(/<thinking>/gi, "")
+    .replace(/<\/thinking>/gi, "")
+    .replace(/<think>/gi, "")
+    .replace(/<\/think>/gi, "")
+    .replace(/<:[^>]*>/gi, "");
+}
+
 /** Strip common markdown formatting so titles render as plain text. */
 function stripMarkdown(text: string): string {
   return text
@@ -458,7 +474,7 @@ function buildRegenerationPrompt(recentMessages: MessageRow[]): string {
     const text = extractTextForTitle(msg.content);
     if (!text) continue;
     const role = msg.role === "user" ? "User" : "Assistant";
-    parts.push(`${role}: ${text}`);
+    parts.push(`${role}: ${stripThinkingTags(text)}`);
   }
 
   return parts.join("\n");

package/src/memory/db-async-query.ts

@@ -0,0 +1,214 @@
+/**
+ * Run a SQL statement asynchronously, without blocking the daemon's
+ * main event loop.
+ *
+ * `bun:sqlite` is synchronous, so any long-running statement on the
+ * shared in-process connection stalls the event loop for the full
+ * duration of the statement. For multi-minute operations like `VACUUM`
+ * on a multi-GB database, this stalls every other piece of I/O —
+ * including the healthz handler — and on platform that has been
+ * observed to fail liveness probes and crashloop the pod.
+ *
+ * Backend selection:
+ *   1. **`sqlite3` CLI subprocess (preferred).** Spawn a child process
+ *      that opens its own SQLite connection, runs the statement, and
+ *      exits. The daemon's event loop is free for the full duration.
+ *      SQLite's own file-locking arbitrates between the subprocess and
+ *      the still-running in-process connection.
+ *   2. **In-process `bun:sqlite` (fallback).** Synchronous, blocking.
+ *      Only fires when no `sqlite3` binary is on the host. This is the
+ *      same behavior the daemon had before this abstraction existed,
+ *      and is acceptable on desktop where no liveness probe is going to
+ *      kill the process for a long stall.
+ *
+ * Use this for statements known to be slow (`VACUUM`, `ANALYZE`,
+ * `PRAGMA optimize`, large bulk `DELETE`/`UPDATE`). Fast queries (a few
+ * ms) should keep using the in-process drizzle / `bun:sqlite` handle
+ * directly — the subprocess overhead would dominate.
+ */
+import { getLogger } from "../util/logger.js";
+import { getDbPath } from "../util/platform.js";
+import { findSqlite3 } from "../util/sqlite3-runtime.js";
+import { getSqlite } from "./db-connection.js";
+
+const log = getLogger("db-async-query");
+
+/**
+ * Default wall-clock cap for an async statement. A real `VACUUM` on a
+ * multi-GB database can legitimately take many minutes; the cap is
+ * here to bound a runaway subprocess (e.g. one stuck on a stale file
+ * lock). Override per call via `runAsyncSqlite(sql, { timeoutMs })`.
+ */
+const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+
+export type AsyncSqliteBackend = "sqlite3-cli" | "in-process-blocking";
+
+export interface AsyncSqliteResult {
+  ok: boolean;
+  backend: AsyncSqliteBackend;
+  error: string | null;
+  elapsedMs: number;
+  stdout?: string;
+  stderr?: string;
+  timedOut?: boolean;
+}
+
+export interface RunAsyncSqliteOptions {
+  /** Override the default 1 h subprocess timeout. */
+  timeoutMs?: number;
+  /**
+   * Force a specific backend. Test-only; production callers should let
+   * the runtime pick.
+   */
+  forceBackend?: AsyncSqliteBackend;
+}
+
+let warnedAboutFallback = false;
+
+export async function runAsyncSqlite(
+  sql: string,
+  options: RunAsyncSqliteOptions = {},
+): Promise<AsyncSqliteResult> {
+  const forced = options.forceBackend;
+  const sqlite3Path =
+    forced === "in-process-blocking" ? undefined : findSqlite3();
+
+  if (sqlite3Path && forced !== "in-process-blocking") {
+    return runViaCli(sqlite3Path, sql, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  }
+
+  if (!warnedAboutFallback) {
+    warnedAboutFallback = true;
+    log.warn(
+      "No sqlite3 CLI found on host — falling back to in-process blocking " +
+        "execution for slow SQLite statements. Install sqlite3 to keep the " +
+        "event loop responsive during VACUUM and other long operations.",
+    );
+  }
+  return runInProcessBlocking(sql);
+}
+
+/** For tests: reset the once-only fallback warning. */
+export function _resetFallbackWarning(): void {
+  warnedAboutFallback = false;
+}
+
+async function runViaCli(
+  sqlite3Path: string,
+  sql: string,
+  timeoutMs: number,
+): Promise<AsyncSqliteResult> {
+  const startMs = Date.now();
+  const dbPath = getDbPath();
+
+  log.info(
+    { sqlite3Path, dbPath, timeoutMs, sqlPreview: sql.slice(0, 80) },
+    "Running async SQL via sqlite3 CLI subprocess",
+  );
+
+  // Pass the SQL via stdin rather than -cmd so newlines and quoting are
+  // never an issue regardless of the statement complexity.
+  const proc = Bun.spawn({
+    cmd: [sqlite3Path, dbPath],
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  // Write the SQL and close stdin so sqlite3 sees EOF and exits.
+  proc.stdin.write(sql + "\n");
+  await proc.stdin.end();
+
+  // Begin draining the streams immediately so the subprocess never
+  // blocks on a full pipe buffer.
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    proc.kill("SIGKILL");
+  }, timeoutMs);
+  if (typeof timer.unref === "function") timer.unref();
+
+  const exitCode = await proc.exited;
+  clearTimeout(timer);
+
+  const stdout = await stdoutPromise;
+  const stderr = await stderrPromise;
+  const elapsedMs = Date.now() - startMs;
+
+  if (timedOut) {
+    log.error(
+      { timeoutMs, elapsedMs, stderr: stderr.slice(0, 2000) },
+      "Async SQL subprocess timed out — killed",
+    );
+    return {
+      ok: false,
+      backend: "sqlite3-cli",
+      error: `sqlite3 subprocess timed out after ${timeoutMs}ms`,
+      elapsedMs,
+      stdout,
+      stderr,
+      timedOut: true,
+    };
+  }
+  if (exitCode !== 0) {
+    log.error(
+      { exitCode, elapsedMs, stderr: stderr.slice(0, 2000) },
+      "Async SQL subprocess failed",
+    );
+    return {
+      ok: false,
+      backend: "sqlite3-cli",
+      error: `sqlite3 exited with code ${exitCode}: ${stderr.slice(0, 500)}`,
+      elapsedMs,
+      stdout,
+      stderr,
+    };
+  }
+  return {
+    ok: true,
+    backend: "sqlite3-cli",
+    error: null,
+    elapsedMs,
+    stdout,
+    stderr,
+  };
+}
+
+async function runInProcessBlocking(sql: string): Promise<AsyncSqliteResult> {
+  const startMs = Date.now();
+  try {
+    const sqlite = getSqlite();
+    sqlite.exec(sql);
+    // Synthesize `stdout` to match what the CLI backend would emit
+    // when the caller chained `SELECT changes();` at the end of their
+    // SQL. `bun:sqlite`'s `exec()` discards SELECT results, so without
+    // this synthesis, callers that read `stdout` to get the row count
+    // (the prune jobs in cleanup.ts, for one) would see `undefined`
+    // and treat the run as "no rows deleted" — silently dropping the
+    // re-enqueue gate on every fallback host. Captured atomically with
+    // exec (same synchronous slice — no other code can run between
+    // these two lines), so the count is accurate for the SQL we just
+    // ran. Harmless for callers that don't read stdout.
+    const changes = (
+      sqlite.query("SELECT changes() AS c").get() as { c: number }
+    ).c;
+    return {
+      ok: true,
+      backend: "in-process-blocking",
+      error: null,
+      elapsedMs: Date.now() - startMs,
+      stdout: `${changes}\n`,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      backend: "in-process-blocking",
+      error: message,
+      elapsedMs: Date.now() - startMs,
+    };
+  }
+}

package/src/memory/db-init.ts

@@ -118,9 +118,11 @@ import {
   migrateInviteCodeHashColumn,
   migrateInviteContactId,
   migrateLlmRequestLogAgentLoopExitReason,
+  migrateLlmRequestLogCallSite,
   migrateLlmRequestLogMessageId,
   migrateLlmRequestLogProvider,
   migrateLlmRequestLogsCreatedAtIndex,
+  migrateLlmUsageAddRawUsage,
   migrateLlmUsageAttribution,
   migrateMemoryGraphImageRefs,
   migrateMemoryItemSupersession,
@@ -128,6 +130,8 @@ import {
   migrateMemoryRetrospectiveState,
   migrateMemoryV2ActivationLogs,
   migrateMemoryV2InjectionEvents,
+  migrateMemoryV3AutoEdges,
+  migrateMemoryV3Coactivation,
   migrateMessageBookmarks,
   migrateMessagesConversationCreatedAtIndex,
   migrateMessagesFtsBackfill,
@@ -155,6 +159,7 @@ import {
   migrateProviderConnectionStatusLabel,
   migrateReminderRoutingIntent,
   migrateRemindersToSchedules,
+  migrateRenameCleanedAt,
   migrateRenameConversationTypeColumn,
   migrateRenameCreatedBySessionIdColumns,
   migrateRenameFollowupsThreadIdColumn,
@@ -452,6 +457,11 @@ export function initializeDb(): void {
     migrateStripBaseUrlNonOpenaiCompatible,
     migrateOnboardingEventsPriorAssistants,
     migrateConversationCleanedAt,
+    migrateRenameCleanedAt,
+    migrateLlmUsageAddRawUsage,
+    migrateMemoryV3Coactivation,
+    migrateMemoryV3AutoEdges,
+    migrateLlmRequestLogCallSite,
   ];
 
   // Run each migration step, catching and logging individual failures so one

package/src/memory/db-maintenance.ts

@@ -3,6 +3,7 @@ import { statSync } from "node:fs";
 import { getLogger } from "../util/logger.js";
 import { getDbPath } from "../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
+import { runAsyncSqlite } from "./db-async-query.js";
 import { getSqlite } from "./db-connection.js";
 
 const log = getLogger("db-maintenance");
@@ -11,7 +12,7 @@ const DB_MAINTENANCE_CHECKPOINT_KEY = "db_maintenance:last_run";
 const DB_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 interface DbStats {
-  pageSizeBytes: number;
+  pageSize: number;
   pageCount: number;
   freelistCount: number;
   fileSizeBytes: number | null;
@@ -19,7 +20,7 @@ interface DbStats {
 
 function getDbStats(): DbStats {
   const sqlite = getSqlite();
-  const pageSizeBytes = (
+  const pageSize = (
     sqlite.query("PRAGMA page_size").get() as { page_size: number }
   ).page_size;
   const pageCount = (
@@ -34,10 +35,10 @@ function getDbStats(): DbStats {
   } catch {
     /* non-fatal */
   }
-  return { pageSizeBytes, pageCount, freelistCount, fileSizeBytes };
+  return { pageSize, pageCount, freelistCount, fileSizeBytes };
 }
 
-function runDbMaintenance(): void {
+async function runDbMaintenance(): Promise<void> {
   const before = getDbStats();
   const freelistPct =
     before.pageCount > 0
@@ -54,22 +55,24 @@ function runDbMaintenance(): void {
     "Starting database maintenance",
   );
 
-  try {
-    getSqlite().exec("VACUUM");
-  } catch (err) {
-    log.warn({ err }, "VACUUM failed (non-fatal)");
-    try {
-      getSqlite().exec("PRAGMA optimize");
-    } catch (optErr) {
-      log.warn({ err: optErr }, "PRAGMA optimize failed (non-fatal)");
-    }
-    return;
+  // VACUUM is the long-running one — minutes on a multi-GB DB. PRAGMA
+  // optimize is fast but routed through the same async path for
+  // consistency and to keep both off the main thread when the CLI
+  // backend is available.
+  const vacuumResult = await runAsyncSqlite("VACUUM");
+  if (!vacuumResult.ok) {
+    log.warn(
+      { error: vacuumResult.error, backend: vacuumResult.backend },
+      "VACUUM failed (non-fatal)",
+    );
   }
 
-  try {
-    getSqlite().exec("PRAGMA optimize");
-  } catch (err) {
-    log.warn({ err }, "PRAGMA optimize failed (non-fatal)");
+  const optimizeResult = await runAsyncSqlite("PRAGMA optimize");
+  if (!optimizeResult.ok) {
+    log.warn(
+      { error: optimizeResult.error, backend: optimizeResult.backend },
+      "PRAGMA optimize failed (non-fatal)",
+    );
   }
 
   const after = getDbStats();
@@ -81,17 +84,23 @@ function runDbMaintenance(): void {
 
   log.info(
     {
+      backend: vacuumResult.backend,
+      vacuumOk: vacuumResult.ok,
+      optimizeOk: optimizeResult.ok,
+      vacuumElapsedMs: vacuumResult.elapsedMs,
+      optimizeElapsedMs: optimizeResult.elapsedMs,
       beforePageCount: before.pageCount,
       afterPageCount: after.pageCount,
       reclaimedPages,
-      reclaimedBytes,
+      beforeFileSizeBytes: before.fileSizeBytes,
       afterFileSizeBytes: after.fileSizeBytes,
+      reclaimedBytes,
     },
     "Database maintenance complete",
   );
 }
 
-export function maybeRunDbMaintenance(nowMs = Date.now()): void {
+export async function maybeRunDbMaintenance(nowMs = Date.now()): Promise<void> {
   const lastRun = parseInt(
     getMemoryCheckpoint(DB_MAINTENANCE_CHECKPOINT_KEY) ?? "0",
     10,
@@ -99,7 +108,7 @@ export function maybeRunDbMaintenance(nowMs = Date.now()): void {
   if (nowMs - lastRun < DB_MAINTENANCE_INTERVAL_MS) return;
 
   try {
-    runDbMaintenance();
+    await runDbMaintenance();
   } catch (err) {
     log.error({ err }, "Database maintenance failed unexpectedly");
   }

package/src/memory/graph/bootstrap.ts

@@ -20,7 +20,11 @@ import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
 import { getDb } from "../db-connection.js";
-import { enqueueMemoryJob, hasActiveJobOfType } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  hasActiveJobOfType,
+  isMemoryEnabled,
+} from "../jobs-store.js";
 import { initQdrantClient, resolveQdrantUrl } from "../qdrant-client.js";
 import { rawAll, rawGet, rawRun } from "../raw-query.js";
 import { conversations, memoryGraphNodes, memorySegments } from "../schema.js";
@@ -342,6 +346,8 @@ export function maybeEnqueueGraphBootstrap(): void {
   // Don't enqueue if already in progress
   if (hasActiveJobOfType("graph_bootstrap")) return;
 
+  if (!isMemoryEnabled()) return;
+
   log.info(
     { segmentCount, hasJournalFiles },
     "Graph empty with historical data — enqueueing bootstrap",
@@ -392,6 +398,7 @@ const KIND_TO_PREFIX: Record<string, string> = {
  */
 export function migrateToolCreatedItems(): void {
   if (getMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT)) return;
+  if (!isMemoryEnabled()) return;
 
   const kinds = Object.keys(KIND_TO_PREFIX);
   const placeholders = kinds.map(() => "?").join(", ");

package/src/memory/graph/capability-seed.ts

@@ -23,7 +23,7 @@ import {
 } from "../../skills/skill-memory.js";
 import { getLogger } from "../../util/logger.js";
 import { getDb } from "../db-connection.js";
-import { enqueueMemoryJob } from "../jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "../jobs-store.js";
 import { memoryGraphNodes } from "../schema.js";
 import { createNode } from "./store.js";
 
@@ -268,7 +268,9 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
       })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
-    enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    if (isMemoryEnabled()) {
+      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    }
     return;
   }
 
@@ -301,7 +303,9 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     scopeId: "default",
   });
 
-  enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+  if (isMemoryEnabled()) {
+    enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+  }
   log.info({ sourceKey, nodeId: node.id }, "Created capability graph node");
 }
 

package/src/memory/graph/conversation-graph-memory.ts

@@ -35,6 +35,7 @@ import {
   type InjectMemoryV2Mode,
 } from "../v2/injection.js";
 import { loadNowText } from "../v2/now-text.js";
+import type { RouterTurnPair } from "../v2/router.js";
 import {
   loadGraphMemoryState,
   saveGraphMemoryState,
@@ -440,8 +441,11 @@ export class ConversationGraphMemory {
       messages,
       config,
       "context-load",
+      // Context-load runs before the messages array necessarily contains
+      // the just-arrived user turn (post-compaction restore, turn 1
+      // sketch), so override with the resolved user text rather than
+      // walking back through `messages`.
       rawUserText ?? userQuery ?? "",
-      "",
       signal,
     );
 
@@ -605,8 +609,7 @@ export class ConversationGraphMemory {
       messages,
       config,
       "per-turn",
-      userLast,
-      assistantLast,
+      null,
       signal,
     );
     if (v2.routed) {
@@ -762,8 +765,14 @@ export class ConversationGraphMemory {
     messages: Message[],
     config: AssistantConfig,
     mode: InjectMemoryV2Mode,
-    userMessage: string,
-    assistantMessage: string,
+    /**
+     * Override for the just-arrived user message text. Used by
+     * `runContextLoad` where the conversation history may not yet contain
+     * the user message that triggered the load (e.g. turn 1 / post-
+     * compaction restoration). When provided, the extracted pairs array
+     * is replaced with `[{ assistantMessage: "", userMessage: override }]`.
+     */
+    userMessageOverride: string | null,
     signal: AbortSignal,
   ): Promise<{
     routed: boolean;
@@ -776,13 +785,17 @@ export class ConversationGraphMemory {
 
     const nowText = await loadNowText(getWorkspaceDir());
     const currentTurn = this.tracker.getTurn();
+    const historicalPairs = config.memory.v2.router.historical_pairs;
+    const recentTurnPairs =
+      userMessageOverride !== null
+        ? [{ assistantMessage: "", userMessage: userMessageOverride }]
+        : extractRecentTurnPairs(messages, historicalPairs);
 
     const result = await injectMemoryV2Block({
       database: getDb(),
       conversationId: this.conversationId,
       currentTurn,
-      userMessage,
-      assistantMessage,
+      recentTurnPairs,
       nowText,
       messageId: `${this.conversationId}:turn:${currentTurn}`,
       mode,
@@ -808,16 +821,22 @@ export class ConversationGraphMemory {
 
 /**
  * Count the leading content blocks on a user message that were added by
- * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
- * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted).
- * The bare `<memory>` form is matched only when the block also ends with
- * `\n</memory>`, so user-authored content that happens to begin with
- * `<memory>` (for example, a message discussing the XML-like markup) is not
- * mistaken for an injected prefix and stripped on re-injection. A legacy
- * 2-block image pattern (no closing tag) is also accepted for backward
- * compatibility. The injection prefix is always contiguous at the start,
- * so we stop at the first non-memory block.
+ * `injectMemoryBlock` or the `memory-v2-static` injector. Memory-injected
+ * images use a 3-block pattern (opening `<memory_image>` text + image +
+ * closing `</memory_image>` text), followed by a `<memory>…</memory>` text
+ * block (legacy `<memory __injected>` is also accepted). The static
+ * memory-v2 block uses `<info>…</info>` and is also counted here so that
+ * `after-memory-prefix` splices for subsequent injectors (e.g. `now-md`)
+ * land after both the dynamic and static blocks.
+ *
+ * The bare `<memory>` and `<info>` forms are matched only when the block
+ * also ends with the corresponding closing tag, so user-authored content
+ * that happens to begin with `<memory>` or `<info>` (for example, a
+ * message discussing the XML-like markup) is not mistaken for an injected
+ * prefix and stripped on re-injection. A legacy 2-block image pattern (no
+ * closing tag) is also accepted for backward compatibility. The injection
+ * prefix is always contiguous at the start, so we stop at the first
+ * non-memory block.
  */
 export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
   let firstNonMemory = 0;
@@ -829,6 +848,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
       block.type === "text" &&
       ((block.text.startsWith("<memory>\n") &&
         block.text.endsWith("\n</memory>")) ||
+        (block.text.startsWith("<info>\n") &&
+          block.text.endsWith("\n</info>")) ||
         block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;
@@ -991,3 +1012,65 @@ function readRawUserText(message: Message | undefined): string | null {
   if (texts.length === 0) return null;
   return texts.join(" ");
 }
+
+/**
+ * Walk back through the conversation history and collect the most recent
+ * `K` `(assistant, user)` turn pairs for the router prompt. Each pair
+ * represents the assistant's reply followed by the user message that
+ * came after — the last pair's `userMessage` is the just-arrived turn
+ * that triggered this call.
+ *
+ * Behavior at K=1 is bit-identical to the pre-knob signature: one pair
+ * with the prior assistant reply + the just-arrived user message.
+ *
+ * Edge cases:
+ *   - If history has fewer than K full pairs available (e.g. early in a
+ *     conversation), returns however many pairs were found, oldest first.
+ *     The oldest pair may have `assistantMessage: ""` when there is a
+ *     user message with no preceding assistant reply — `runRouterBatch`
+ *     skips the `[assistant]:` line in that case.
+ *   - Non-text content (tool_use, tool_result, images) is collapsed by
+ *     joining all text blocks within a single message with spaces. This
+ *     matches the v1-style extraction the router has used since K=1.
+ */
+function extractRecentTurnPairs(
+  messages: Message[],
+  k: number,
+): RouterTurnPair[] {
+  const messageText = (msg: Message): string =>
+    msg.content
+      .filter(
+        (b): b is Extract<typeof b, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join(" ");
+
+  const pairs: RouterTurnPair[] = [];
+  let pendingUser: string | null = null;
+  for (let i = messages.length - 1; i >= 0 && pairs.length < k; i--) {
+    const msg = messages[i];
+    if (msg.role === "user" && pendingUser === null) {
+      pendingUser = messageText(msg);
+    } else if (msg.role === "assistant" && pendingUser !== null) {
+      pairs.unshift({
+        assistantMessage: messageText(msg),
+        userMessage: pendingUser,
+      });
+      pendingUser = null;
+    }
+  }
+  // Conversation start: a user message with no preceding assistant reply
+  // still belongs in the prompt as the just-arrived turn. Emit it with an
+  // empty `assistantMessage` so `runRouterBatch` renders only `[user]:`.
+  if (pendingUser !== null && pairs.length < k) {
+    pairs.unshift({ assistantMessage: "", userMessage: pendingUser });
+  }
+  // Defensive fallback: the router contract requires a non-empty array.
+  // This only fires when `messages` has no user-text content at all
+  // (currently impossible since the agent loop always appends a user
+  // turn before invoking the v2 path, but cheap to keep correct).
+  if (pairs.length === 0) {
+    pairs.push({ assistantMessage: "", userMessage: "" });
+  }
+  return pairs;
+}