@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/plugins/defaults/memory/v3/plugin-schema.ts

@@ -1,7 +1,8 @@
 /**
  * The memory-v3 plugin's own schema on the dedicated memory connection
- * (`assistant-memory.db`): the `memory_v3_pools` and
- * `memory_v3_injected_sections` tables, and the `section_key` column of
+ * (`assistant-memory.db`): the `memory_v3_pools`, `memory_v3_pool_inputs`,
+ * `memory_v3_pool_texts`, and `memory_v3_injected_sections` tables, and the
+ * `section_key` column of
  * `memory_v3_selections`. Plugin storage is created by the plugin,
  * idempotently and fail-open, never by the global migration chain that gates
  * database readiness: the memory plugin's `init` hook runs every ensure on
@@ -153,6 +154,53 @@ export const ensureMemoryV3PoolsSchemaOnce = ensureOncePerConnection(
   "failed to ensure memory_v3_pools; pool logging degraded",
 );
 
+const POOL_INPUTS_TABLE = "memory_v3_pool_inputs";
+const POOL_TEXTS_TABLE = "memory_v3_pool_texts";
+
+/**
+ * Create the pool input capture tables, written only under
+ * `memory.v3.poolLog.captureInput` (`pool-log-store.ts`):
+ * `memory_v3_pool_inputs`, one row per `(conversation, turn)` holding the
+ * context strings the selector was given, the gate and keep-all facts, and
+ * the content hash of every pooled candidate's rendered text in pool order
+ * (aligned with the turn's `memory_v3_pools` candidates); and
+ * `memory_v3_pool_texts`, each rendered text once, keyed by that hash, so a
+ * stable-prefix card repeated across turns is stored once. Idempotent
+ * (`IF NOT EXISTS`).
+ */
+export function ensureMemoryV3PoolInputsSchema(memoryRaw: MemorySqlite): void {
+  memoryRaw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS ${POOL_INPUTS_TABLE} (
+      conversation_id TEXT NOT NULL,
+      turn INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      situational_context TEXT,
+      recent_context TEXT NOT NULL,
+      current_message TEXT NOT NULL,
+      previous_assistant_message TEXT,
+      selector_prompt_hash TEXT,
+      kept_all INTEGER NOT NULL DEFAULT 0,
+      gate_reason TEXT,
+      candidate_text_hashes_json TEXT NOT NULL,
+      PRIMARY KEY (conversation_id, turn)
+    )
+  `);
+  memoryRaw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS ${POOL_TEXTS_TABLE} (
+      text_hash TEXT PRIMARY KEY,
+      text TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+
+/** {@link ensureMemoryV3PoolInputsSchema} once per connection in this
+ *  process, for the pool input capture's writer and readers. */
+export const ensureMemoryV3PoolInputsSchemaOnce = ensureOncePerConnection(
+  ensureMemoryV3PoolInputsSchema,
+  "failed to ensure memory_v3_pool_inputs; pool input capture degraded",
+);
+
 const SECTIONS_TABLE = "memory_v3_injected_sections";
 const LEGACY_CARDS_TABLE = "memory_v3_ever_injected";
 
@@ -331,8 +379,9 @@ export const ensureMemoryV3SelectionsSectionKeyOnce = ensureOncePerConnection(
 
 /**
  * Ensure the whole plugin-owned schema on the memory connection of this
- * process, for the memory plugin's `init` hook: the pools and
- * injected-sections tables and the selection log's `section_key` column,
+ * process, for the memory plugin's `init` hook: the pools, pool input
+ * capture, and injected-sections tables and the selection log's
+ * `section_key` column,
  * each through its once-per-connection wrapper so a store's first use on
  * the same connection is a no-op. No-op when the connection is unavailable
  * (the stores degrade to no-ops as on any turn).
@@ -340,6 +389,7 @@ export const ensureMemoryV3SelectionsSectionKeyOnce = ensureOncePerConnection(
 export function ensureMemoryV3PluginSchema(): void {
   ensuredMemorySqlite("ensureMemoryV3PluginSchema", (raw) => {
     ensureMemoryV3PoolsSchemaOnce(raw);
+    ensureMemoryV3PoolInputsSchemaOnce(raw);
     ensureMemoryV3InjectedSectionsSchemaOnce(raw);
     ensureMemoryV3SelectionsSectionKeyOnce(raw);
   });

package/src/plugins/defaults/memory/v3/pool-log-store.ts

@@ -27,17 +27,39 @@
  * Rows are per-turn diagnostics (roughly 10KB each) with no retention job;
  * a conversation delete purges them with the other conversation-keyed memory
  * tables (`conversation-memory-purge.ts`).
+ *
+ * Under `memory.v3.poolLog.captureInput` (off by default) the turn's row is
+ * joined by the selector's exact input, for offline selector evaluation and
+ * training data: `memory_v3_pool_inputs` (one row per `(conversation,
+ * turn)`: the context strings the selector was given, the selector prompt's
+ * content hash, the gate reason, the keep-all flag, and the content hash of
+ * every pooled candidate's rendered text in pool order, aligned with
+ * `candidates_json`) and `memory_v3_pool_texts` (each rendered text once,
+ * keyed by that hash). `buildPoolInput` derives both from the same
+ * orchestrate result and turn as the pool record, and `writePoolInput` runs
+ * in `writeTurnLog`'s transaction with the pool and selection rows. The
+ * input row is purged with the conversation; the texts are page-derived and
+ * content-keyed, so they are not.
  */
 
+import { createHash } from "node:crypto";
+
 import { getLogger } from "../logging.js";
 import type { MemorySqlite } from "../memory-db.js";
 import type { OrchestrateResult } from "./orchestrate.js";
 import {
   ensuredMemorySqlite,
+  ensureMemoryV3PoolInputsSchemaOnce,
   ensureMemoryV3PoolsSchemaOnce,
   memoryReader,
 } from "./plugin-schema.js";
-import { type FinderLane, sectionKey, type Slug } from "./types.js";
+import { renderFinderLine } from "./pool-select.js";
+import {
+  type FinderLane,
+  type MemoryRoutingTurn,
+  sectionKey,
+  type Slug,
+} from "./types.js";
 
 const log = getLogger("memory-v3-pool-log");
 
@@ -289,3 +311,233 @@ export function readPoolForMessageIds(messageIds: string[]): StoredPool | null {
         .get(...messageIds) as PoolRow | null,
   );
 }
+
+/** Content hash of a rendered candidate text or a selector prompt: the key
+ *  of `memory_v3_pool_texts`. */
+export function hashPoolText(text: string): string {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+/** The selector's exact input for one turn, persisted under
+ *  `memory.v3.poolLog.captureInput` beside the turn's pool record. */
+export interface PoolInputRecord {
+  situational_context: string | null;
+  recent_context: string;
+  current_message: string;
+  previous_assistant_message: string | null;
+  /** Content hash of the selector system prompt the turn ran with; null
+   *  when the selector was not run. */
+  selector_prompt_hash: string | null;
+  /** Whether the selector's recall-safe keep-all fallback fired. */
+  kept_all: boolean;
+  /** The injection gate's reason code; null when the gate did not run. */
+  gate_reason: string | null;
+  /** Content hash of each pooled candidate's rendered text, in pool order:
+   *  index `i` describes the turn's pool record candidate `i`, which the
+   *  selector saw under pool number `i + 1`. Empty when the record is, and
+   *  when the texts could not be captured (a consumer zips by index and
+   *  treats a length mismatch as texts unavailable). */
+  candidate_text_hashes: string[];
+}
+
+/** A turn's input record with the rendered texts its hashes name. */
+export interface PoolInputCapture {
+  input: PoolInputRecord;
+  texts: Map<string, string>;
+}
+
+/**
+ * Build the turn's input capture from an orchestrate result and the turn it
+ * ran on. Each candidate text is exactly what the selector was shown minus
+ * its pool number: a stable-prefix candidate's pre-rendered card, a finder
+ * candidate's rendered line ({@link renderFinderLine}), in the pool
+ * record's order ({@link buildPoolRecord}). A turn whose pool record is
+ * empty (the selector never judged a pool and nothing was selected)
+ * captures the context strings and no candidate texts, so the hashes stay
+ * aligned with that record; a result that carries no selector pool, or one
+ * that disagrees with its lanes on the candidate count, captures no texts
+ * either and logs the mismatch.
+ */
+export function buildPoolInput(
+  result: OrchestrateResult,
+  turn: MemoryRoutingTurn,
+  selectorPrompt: string | undefined,
+): PoolInputCapture {
+  const texts = new Map<string, string>();
+  const hashes: string[] = [];
+  const recordsPool = result.selectorRan || result.selections.length > 0;
+  if (recordsPool) {
+    const { core, hot, fresh, always, finder } = result.lanes;
+    const expected =
+      core.length + hot.length + fresh.length + always.length + finder.length;
+    const rendered =
+      result.pool === undefined
+        ? undefined
+        : [
+            ...result.pool.stable.map((candidate) => candidate.card),
+            ...result.pool.finder.map((candidate) =>
+              renderFinderLine(candidate),
+            ),
+          ];
+    if (rendered === undefined || rendered.length !== expected) {
+      log.warn(
+        {
+          conversationId: turn.conversationId,
+          turnNumber: turn.turnNumber,
+          rendered: rendered?.length ?? null,
+          expected,
+        },
+        "memory-v3 pool input capture: the result's pool does not match its lanes; capturing no candidate texts",
+      );
+    } else {
+      for (const text of rendered) {
+        const hash = hashPoolText(text);
+        hashes.push(hash);
+        texts.set(hash, text);
+      }
+    }
+  }
+  return {
+    input: {
+      situational_context: turn.situationalContext ?? null,
+      recent_context: turn.recentContext,
+      current_message: turn.currentMessage,
+      previous_assistant_message: turn.previousAssistantMessage ?? null,
+      selector_prompt_hash:
+        result.selectorRan && selectorPrompt !== undefined
+          ? hashPoolText(selectorPrompt)
+          : null,
+      kept_all: result.keptAll ?? false,
+      gate_reason: result.gateReason ?? null,
+      candidate_text_hashes: hashes,
+    },
+    texts,
+  };
+}
+
+/**
+ * Write the turn's input row and its candidate texts on `raw`, their tables
+ * ensured first (`plugin-schema.ts`). The row's PK is `(conversation_id,
+ * turn)`, so a re-observed turn overwrites it in step with its pool row;
+ * each text is inserted by hash and ignored when already stored. Throws on
+ * a failed statement: `writeTurnLog` in `shadow-plugin.ts` runs this inside
+ * the transaction that writes the turn's pool and selection rows, and owns
+ * the best-effort boundary around it.
+ */
+export function writePoolInput(
+  raw: MemorySqlite,
+  conversationId: string,
+  turn: number,
+  capture: PoolInputCapture,
+): void {
+  ensureMemoryV3PoolInputsSchemaOnce(raw);
+  const now = Date.now();
+  const { input, texts } = capture;
+  raw
+    .query(
+      /*sql*/ `
+      INSERT OR REPLACE INTO memory_v3_pool_inputs (
+        conversation_id, turn, created_at, situational_context, recent_context,
+        current_message, previous_assistant_message, selector_prompt_hash,
+        kept_all, gate_reason, candidate_text_hashes_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    )
+    .run(
+      conversationId,
+      turn,
+      now,
+      input.situational_context,
+      input.recent_context,
+      input.current_message,
+      input.previous_assistant_message,
+      input.selector_prompt_hash,
+      input.kept_all ? 1 : 0,
+      input.gate_reason,
+      JSON.stringify(input.candidate_text_hashes),
+    );
+  const insertText = raw.query(/*sql*/ `
+      INSERT OR IGNORE INTO memory_v3_pool_texts (text_hash, text, created_at)
+      VALUES (?, ?, ?)
+    `);
+  for (const [hash, text] of texts) {
+    insertText.run(hash, text, now);
+  }
+}
+
+interface PoolInputRow {
+  situational_context: string | null;
+  recent_context: string;
+  current_message: string;
+  previous_assistant_message: string | null;
+  selector_prompt_hash: string | null;
+  kept_all: number;
+  gate_reason: string | null;
+  candidate_text_hashes_json: string;
+}
+
+/** Best-effort read over the capture tables, degrading to the fallback when
+ *  the memory connection is unavailable or a statement fails
+ *  (`plugin-schema.ts`). */
+const readPoolInputOr = memoryReader(
+  (context) => ensuredMemorySqlite(context, ensureMemoryV3PoolInputsSchemaOnce),
+  (err, context) =>
+    log.warn(
+      { err, context },
+      "failed to read memory-v3 pool input; treating it as unrecorded",
+    ),
+);
+
+/**
+ * Read the input record for an exact `(conversation, turn)`. `null` when the
+ * turn has none (it ran with the capture off or predates it) or the read
+ * degraded.
+ */
+export function readPoolInputForTurn(
+  conversationId: string,
+  turn: number,
+): PoolInputRecord | null {
+  return readPoolInputOr("readPoolInputForTurn", null, (raw) => {
+    const row = raw
+      .query(
+        /*sql*/ `
+        SELECT situational_context, recent_context, current_message,
+               previous_assistant_message, selector_prompt_hash, kept_all,
+               gate_reason, candidate_text_hashes_json
+        FROM memory_v3_pool_inputs
+        WHERE conversation_id = ? AND turn = ?
+      `,
+      )
+      .get(conversationId, turn) as PoolInputRow | null;
+    if (!row) {
+      return null;
+    }
+    const hashes: unknown = JSON.parse(row.candidate_text_hashes_json);
+    if (!Array.isArray(hashes)) {
+      throw new Error("candidate_text_hashes_json is not an array");
+    }
+    return {
+      situational_context: row.situational_context,
+      recent_context: row.recent_context,
+      current_message: row.current_message,
+      previous_assistant_message: row.previous_assistant_message,
+      selector_prompt_hash: row.selector_prompt_hash,
+      kept_all: row.kept_all === 1,
+      gate_reason: row.gate_reason,
+      candidate_text_hashes: hashes as string[],
+    };
+  });
+}
+
+/** The rendered text stored under `textHash`, or `null` when none is or the
+ *  read degraded. */
+export function readPoolText(textHash: string): string | null {
+  return readPoolInputOr("readPoolText", null, (raw) => {
+    const row = raw
+      .query(
+        /*sql*/ `SELECT text FROM memory_v3_pool_texts WHERE text_hash = ?`,
+      )
+      .get(textHash) as { text: string } | null;
+    return row?.text ?? null;
+  });
+}

package/src/plugins/defaults/memory/v3/pool-select.test.ts

@@ -29,10 +29,14 @@ const realPluginApi = await import("@vellumai/plugin-api");
 
 let selectMockActive = false;
 let sendMessageImpl: (() => Promise<ProviderResponse>) | null = null;
+// The messages of the most recent selector call, for asserting the rendered
+// pool.
+let lastMessages: unknown = null;
 
 const mockProvider = {
   name: "mock-memory-v3-selector",
-  async sendMessage(): Promise<ProviderResponse> {
+  async sendMessage(messages: unknown): Promise<ProviderResponse> {
+    lastMessages = messages;
     if (!sendMessageImpl) {
       throw new Error("sendMessageImpl not configured");
     }
@@ -50,7 +54,7 @@ mock.module("@vellumai/plugin-api", () => ({
       : realPluginApi.getConfiguredProvider(...args),
 }));
 
-const { MemoryV3RetrievalUnavailableError, selectPool } =
+const { MemoryV3RetrievalUnavailableError, renderFinderLine, selectPool } =
   await import("./pool-select.js");
 
 function response(content: ContentBlock[]): ProviderResponse {
@@ -143,6 +147,35 @@ describe("selectPool", () => {
     });
   });
 
+  test("a finder line is shown as its pool number and renderFinderLine", async () => {
+    sendMessageImpl = async () =>
+      response([
+        {
+          type: "tool_use",
+          id: "call-1",
+          name: "select_pages",
+          input: { ids: [] },
+        },
+      ]);
+    const candidate = {
+      slug: "page-a" as Slug,
+      descriptor: "a descriptor",
+      lane: "needle",
+    };
+    await selectPool(
+      {
+        stable: [{ slug: "page-s" as Slug, card: "card s" }],
+        finder: [candidate],
+      },
+      turn,
+    );
+    const sent = JSON.stringify(lastMessages);
+    expect(sent).toContain(
+      JSON.stringify(`[2] ${renderFinderLine(candidate)}`).slice(1, -1),
+    );
+    expect(sent).toContain(JSON.stringify("[1] card s").slice(1, -1));
+  });
+
   test("an empty candidate pool returns no selections", async () => {
     expect(await selectPool({ stable: [], finder: [] }, turn)).toEqual({
       pages: [],

package/src/plugins/defaults/memory/v3/pool-select.ts

@@ -42,9 +42,11 @@
  *   - infrastructure failure (selector provider unavailable — e.g. a transient
  *     CES credential blip drops the API key — or no usable `tool_use` / schema
  *     mismatch surviving the short re-prompt retry) → throw
- *     {@link MemoryV3RetrievalUnavailableError}. The live injector treats this
- *     as a logged memory miss for the turn; shadow/observation callers swallow
- *     it so v2 retrieval can serve the turn.
+ *     {@link MemoryV3RetrievalUnavailableError}. The orchestrator keeps the
+ *     stable prefix unjudged for the turn and drops the finder candidates,
+ *     recording the pool with `selector_ran = 0`; the live injector renders
+ *     that prefix and queues a notice that the turn drew on core memories
+ *     only.
  */
 
 import type {
@@ -52,12 +54,12 @@ import type {
   Message,
   ToolUseContent,
 } from "@vellumai/plugin-api";
-import { getConfiguredProvider } from "@vellumai/plugin-api";
+import { getConfiguredProvider, safeStringSlice } from "@vellumai/plugin-api";
 import { z } from "zod";
 
 import { classifyConversationError } from "../../../../daemon/conversation-error.js";
 import type { PendingConversationNotice } from "../../../../daemon/conversation-notices.js";
-import { redactLogString, safeStringSlice, truncate } from "../host-utils.js";
+import { redactLogString, truncate } from "../host-utils.js";
 import {
   cachedTextBlock,
   extractToolUse,
@@ -406,22 +408,31 @@ function laneTag(candidate: PoolCandidate): string {
     : `(${candidate.lane}: ${word}) `;
 }
 
+/**
+ * One finder line as the selector sees it, minus its pool number: the lane
+ * tag (omitted for a candidate without one, naming the keyed word for a
+ * rare-term line, `(rare: turnip)`), the slug, and the snippet after a dash
+ * (no dash for a candidate with an empty descriptor). Shared with the pool
+ * input capture (`pool-log-store.ts`), so the persisted text is exactly the
+ * rendered line.
+ */
+export function renderFinderLine(candidate: PoolCandidate): string {
+  const snippet = renderSnippet(candidate);
+  const lane = laneTag(candidate);
+  return snippet.length > 0
+    ? `${lane}${candidate.slug} — ${snippet}`
+    : `${lane}${candidate.slug}`;
+}
+
 /**
  * Render the finder tail: one `[m+i] (lane) slug — snippet` line per
- * candidate, numbered continuing after the `offset` stable-prefix cards. The
- * lane tag is omitted for a candidate without one and names the keyed word
- * for a rare-term line (`(rare: turnip)`); a candidate with an empty
- * descriptor renders without the dash.
+ * candidate ({@link renderFinderLine}), numbered continuing after the
+ * `offset` stable-prefix cards.
  */
 function renderFinderSegment(finder: PoolCandidate[], offset: number): string {
-  const lines = finder.map((c, i) => {
-    const snippet = renderSnippet(c);
-    const id = offset + i + 1;
-    const lane = laneTag(c);
-    return snippet.length > 0
-      ? `[${id}] ${lane}${c.slug} — ${snippet}`
-      : `[${id}] ${lane}${c.slug}`;
-  });
+  const lines = finder.map(
+    (c, i) => `[${offset + i + 1}] ${renderFinderLine(c)}`,
+  );
   return `<candidates>\n${lines.join("\n")}\n</candidates>`;
 }
 
@@ -500,8 +511,9 @@ export interface PoolSelection {
  *
  * An omitted `ids` keeps ALL candidates (the recall-safe "all of these are
  * relevant" signal, `keptAll: true`); an explicit `[]` keeps none; an
- * infrastructure failure (after a short re-prompt retry) keeps none, degrading
- * to the deterministic recall lanes the orchestrator unions in.
+ * infrastructure failure (after a short re-prompt retry) throws
+ * {@link MemoryV3RetrievalUnavailableError}, and the orchestrator keeps the
+ * stable prefix unjudged in its place.
  *
  * `systemPrompt` is the selector's instruction scaffold; it defaults to the
  * bundled {@link SYSTEM_PROMPT} and is overridable via `memory.v3.selectorPromptPath`

package/src/plugins/defaults/memory/v3/sections.ts

@@ -1,4 +1,5 @@
-import { safeStringSlice } from "../host-utils.js";
+import { safeStringSlice } from "@vellumai/plugin-api";
+
 import type { Section, SectionIndex, Slug } from "./types.js";
 
 /**

package/src/plugins/defaults/memory/v3/shadow-plugin.ts

@@ -19,7 +19,9 @@
  *   3. Run {@link orchestrate} and record its selection set to
  *      `memory_v3_selections` with a best-effort lane attribution, plus the
  *      full candidate pool and verdict to `memory_v3_pools` for the inspector,
- *      as one transaction ({@link writeTurnLog}).
+ *      and, under `memory.v3.poolLog.captureInput`, the selector's exact
+ *      input to `memory_v3_pool_inputs` / `memory_v3_pool_texts`, as one
+ *      transaction ({@link writeTurnLog}).
  *
  * {@link observeTurn} wraps everything in try/catch — any failure is logged and
  * swallowed so it can never affect the live turn. The injector treats a
@@ -32,6 +34,7 @@ import {
   getMessages,
   listInstalledSkills,
   parseMessageMetadata,
+  safeStringSlice,
   stringifyMessageContent,
   VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
 } from "@vellumai/plugin-api";
@@ -44,7 +47,7 @@ import {
   timeLatencySubSpan,
 } from "../../../../daemon/turn-latency-sub-spans.js";
 import { enqueueMemoryJob } from "../../../../persistence/jobs-store.js";
-import { safeStringSlice, stripCommentLines } from "../host-utils.js";
+import { stripCommentLines } from "../host-utils.js";
 import { getLogger } from "../logging.js";
 import { type MemorySqlite, memorySqliteOrNull } from "../memory-db.js";
 import { getWorkspaceDir, getWorkspacePromptPath } from "../paths.js";
@@ -69,9 +72,12 @@ import type { OrchestrateResult } from "./orchestrate.js";
 import { orchestrate } from "./orchestrate.js";
 import { ensureMemoryV3SelectionsSectionKeyOnce } from "./plugin-schema.js";
 import {
+  buildPoolInput,
   buildPoolRecord,
+  type PoolInputCapture,
   type PoolRecord,
   writePool,
+  writePoolInput,
 } from "./pool-log-store.js";
 import {
   MemoryV3RetrievalUnavailableError,
@@ -635,8 +641,16 @@ interface SelectionRow {
  * The row holds one section per slug: the selection's FIRST selected section
  * (pool order) stands for the page; a page selected with no section (a card,
  * or a section-less edge or learned line) logs none.
+ *
+ * A turn whose selector could not run (`selectorFailure`) logs no rows: its
+ * selections are the stable prefix kept unjudged, and the selection table is
+ * what the hot set's frecency and the learned-edge graph read as judgments.
+ * The pool record still carries the turn for the inspector.
  */
 export function attributeSelections(result: OrchestrateResult): SelectionRow[] {
+  if (result.selectorFailure) {
+    return [];
+  }
   const core = new Set<Slug>(result.lanes.core);
   const hot = new Set<Slug>(result.lanes.hot);
   const fresh = new Set<Slug>(result.lanes.fresh);
@@ -729,20 +743,24 @@ function replaceSelections(
 /**
  * Write the turn's log over the dedicated memory connection: its attributed
  * selection rows to `memory_v3_selections` and its candidate pool to
- * `memory_v3_pools`, in one transaction. A turn observed again (a retried or
- * re-entered turn index) replaces its rows in both tables as a unit, so the
- * pool's `chosen` flags and the selection rows always describe the same
- * observation. Best-effort: an unavailable memory database or a failed
- * statement drops this observation's log rather than affecting the turn, and
- * the transaction leaves the earlier observation's rows in place in both
- * tables. The selection table's plugin-owned `section_key` column is ensured
- * on the first use of a connection in this process (`plugin-schema.ts`).
+ * `memory_v3_pools`, plus, when the caller captured it under
+ * `memory.v3.poolLog.captureInput`, the selector's exact `input` to
+ * `memory_v3_pool_inputs` / `memory_v3_pool_texts`, in one transaction. A
+ * turn observed again (a retried or re-entered turn index) replaces its rows
+ * in every table as a unit, so the pool's `chosen` flags, the selection rows,
+ * and the captured input always describe the same observation. Best-effort:
+ * an unavailable memory database or a failed statement drops this
+ * observation's log rather than affecting the turn, and the transaction
+ * leaves the earlier observation's rows in place in every table. The
+ * selection table's plugin-owned `section_key` column is ensured on the
+ * first use of a connection in this process (`plugin-schema.ts`).
  */
 export function writeTurnLog(
   conversationId: string,
   turn: number,
   rows: SelectionRow[],
   pool: PoolRecord,
+  input?: PoolInputCapture,
 ): void {
   try {
     const raw = memorySqliteOrNull("writeTurnLog");
@@ -753,6 +771,9 @@ export function writeTurnLog(
     raw.transaction(() => {
       replaceSelections(raw, conversationId, turn, rows);
       writePool(raw, conversationId, turn, pool);
+      if (input) {
+        writePoolInput(raw, conversationId, turn, input);
+      }
     })();
   } catch (err) {
     log.warn(
@@ -845,6 +866,10 @@ export async function observeTurn(
     // against the same store the injector renders from. This turn has not
     // committed yet, so the set matches what the injector will see.
     const activeSections = getActiveSections(conversationId);
+    const selectorPrompt = resolveSelectorPrompt(
+      v3.selectorPromptPath,
+      getWorkspaceDir(),
+    );
     const result = await orchestrate(turn, {
       sectionIndex: lanes.sectionIndex,
       needle: lanes.needle,
@@ -877,10 +902,7 @@ export async function observeTurn(
       learnedPerSeed: v3.learnedEdges.perSeed,
       learnedCap: tuning.learnedEdgesCap,
       selectorEnabled: tuning.selectorEnabled,
-      selectorPrompt: resolveSelectorPrompt(
-        v3.selectorPromptPath,
-        getWorkspaceDir(),
-      ),
+      selectorPrompt,
       // Per-turn injection gate: the `memory.v3.gate` tuning, `enabled`
       // kill-switch included. Read-only downstream, so the config object is
       // passed as-is.
@@ -910,6 +932,11 @@ export async function observeTurn(
       turnIndex,
       attributeSelections(result),
       buildPoolRecord(result),
+      // The selector's exact input, captured only when opted in: the context
+      // strings and every pooled candidate's rendered text.
+      v3.poolLog.captureInput
+        ? buildPoolInput(result, turn, selectorPrompt)
+        : undefined,
     );
     recordLatencySubSpan(
       "v3_persist",

package/src/plugins/defaults/tool-error/hooks/post-tool-use.ts

@@ -10,7 +10,10 @@
  * guidance while the client-facing and persisted tool output stay the tool's
  * actual result. This mirrors how Claude Code (`additionalContext`) and Codex
  * (`additional_contexts`) surface PostToolUse feedback as separate context
- * rather than rewriting the tool response.
+ * rather than rewriting the tool response. The one exception is an assistant
+ * turn that left a native web search deferred: its answering message must
+ * hold tool_result blocks alone, so the loop folds the guidance into the
+ * provider-bound copy of the errored tool_result (see `buildToolResultFollowUp`).
  *
  * The coaching is bounded per tool: once a single tool has failed
  * `MAX_CONSECUTIVE_ERROR_NUDGES` times in a row the notice is dropped — the