@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/memory/thread-history.js

@@ -25,11 +25,12 @@ import { metrics } from "@opentelemetry/api";
 import { ResultAsync, ok, okAsync } from "neverthrow";
 import { stripNulCharacters } from "../input-sanitization.js";
 import { tryMutation, tryQuery, withTransaction } from "../lib/db-result.js";
+import { presentFirst } from "../lib/present.js";
 import { hasReportedUsage } from "../loop/metrics.js";
 import { countTokens } from "./count-tokens.js";
 import { conversationView, groupTurns, isGenuineUserStart } from "./conversation-view.js";
 import { HARNESS_PROVIDER_NAMESPACE, SYNTHETIC_MESSAGE_KEY, envelopeMessage, parseStoredMessageEnvelope, syntheticRecordMessage, } from "./ai-sdk-message-storage.js";
-import { conversationDisplayPart, envelopeDisplayMessages, parseStoredDisplayEnvelope, } from "./conversation-display-storage.js";
+import { conversationDisplayPart, envelopeDisplayMessages, isStoredSourcePart, parseStoredDisplayEnvelope, } from "./conversation-display-storage.js";
 /** A resolved `ok(undefined)` ResultAsync — the empty/seed transaction step. */
 function okVoid() {
     return new ResultAsync(Promise.resolve(ok(undefined)));
@@ -56,7 +57,9 @@ export function conversationRecordTurn(text, displayParts) {
             {
                 id: randomUUID(),
                 role: "system",
-                parts: displayParts !== undefined && displayParts.length > 0 ? displayParts.map(conversationDisplayPart) : [{ type: "text", text, state: "done" }],
+                parts: displayParts !== undefined && displayParts.length > 0
+                    ? displayParts.filter(isStoredSourcePart).map(conversationDisplayPart)
+                    : [{ type: "text", text, state: "done" }],
             },
         ],
     };
@@ -128,12 +131,12 @@ function nextSeq(client, threadId, op) {
         const { rows } = await client.query("SELECT COALESCE(MAX(seq), -1)::text AS max_seq FROM messages WHERE thread_id = $1", [
             threadId,
         ]);
-        return Number(rows[0].max_seq) + 1;
+        return Number(presentFirst(rows, "the max-seq row").max_seq) + 1;
     });
 }
 /** Insert the rows of one group, from `startSeq` on. */
 function insertGroup(client, threadId, startSeq, group, op) {
-    const { modelMessages: messages, displayMessages, author } = group;
+    const { modelMessages: messages, displayMessages, author, key } = group;
     // The display projection rides the group's FIRST row, so one SELECT of a
     // thread's rows yields every envelope in order with no join and no grouping.
     // Whichever row that is — a genuine user message opening a turn, or the lone
@@ -154,19 +157,21 @@ function insertGroup(client, threadId, startSeq, group, op) {
     return messages.reduce((chain, message, i) => chain.andThen(() => tryMutation(`${op}.insert`, () => client.query(
     // `message_envelope::json`, never `::jsonb`; `display_envelope::jsonb`,
     // never `::json` — see the column comments in the state-init DDL.
-    `INSERT INTO messages (thread_id, seq, message_envelope, display_envelope, tokens, author)
-                     VALUES ($1, $2, $3::json, $4::jsonb, $5, $6)
+    `INSERT INTO messages (thread_id, seq, message_envelope, display_envelope, tokens, author, round_key)
+                     VALUES ($1, $2, $3::json, $4::jsonb, $5, $6, $7)
                      ON CONFLICT (thread_id, seq) DO UPDATE
                        SET message_envelope = EXCLUDED.message_envelope,
                            display_envelope = EXCLUDED.display_envelope,
                            tokens = EXCLUDED.tokens,
-                           author = EXCLUDED.author`, [
+                           author = EXCLUDED.author,
+                           round_key = EXCLUDED.round_key`, [
         threadId,
         startSeq + i,
         serializeEnvelope(message),
         i === 0 ? displayEnvelope : null,
         countTokens(message.content),
         i === authorRow ? turnAuthor : null,
+        i === 0 ? (key ?? null) : null,
     ])).map(() => undefined)), okVoid());
 }
 /** Move `cortex_analysis_threads.updated_at` forward inside the write transaction. */
@@ -209,6 +214,16 @@ function touchThread(client, threadId, op) {
         .map(() => undefined)
         .orElse(() => okVoid()));
 }
+/** The `seq` of the first row of a group that a write stored before, by the key of the group. */
+function storedGroupSeq(client, threadId, key, op) {
+    if (key === undefined)
+        return okAsync(undefined);
+    return tryQuery(`${op}.storedKey`, async () => {
+        const { rows } = await client.query("SELECT seq::text AS seq FROM messages WHERE thread_id = $1 AND round_key = $2", [threadId, key]);
+        const row = rows[0];
+        return row === undefined ? undefined : Number(row.seq);
+    });
+}
 /** Add the `open` record of a turn. The upsert replaces a record whose rows are gone, because the opening row holds its key now. */
 function openTurnRecord(client, threadId, startSeq) {
     return tryMutation("thread-history.writeTurn.openRecord", () => client.query(`INSERT INTO cortex_thread_turns (thread_id, start_seq, status)
@@ -320,46 +335,50 @@ const PAGE_SQL = `WITH RECURSIVE page_walk(seq, starts) AS (
 function pageLimit(limit) {
     return Number.isFinite(limit) ? Math.min(Math.max(1, Math.trunc(limit)), Number.MAX_SAFE_INTEGER) : 1;
 }
-/**
- * Create a `ThreadHistory` bound to a Postgres pool — a factory closure
- * capturing `pool` (dependency injection per the harness-durable-runtime spec). The `messages` table is
- * provisioned by the project's state-init DDL.
- *
- * `logger` serves exactly one purpose: reporting a stored display part the
- * current vocabulary had to drop. It is optional because the read returns the
- * same messages either way — the drop reports a deploy, not a failed read — and
- * requiring it would break every call site over a diagnostic.
- */
+/** `appendTurn` inside the transaction of the caller, thus another write of the caller commits with the turn or not at all. */
+export function appendTurnIn(client, threadId, turn) {
+    if (turn.modelMessages.length === 0)
+        return okVoid();
+    return lockThread(client, threadId, "thread-history.appendTurn")
+        .andThen(() => nextSeq(client, threadId, "thread-history.appendTurn"))
+        .andThen((startSeq) => insertGroup(client, threadId, startSeq, turn, "thread-history.appendTurn"))
+        .andThen(() => touchThread(client, threadId, "thread-history.appendTurn"));
+}
 export function createThreadHistory(pool, logger) {
     function appendTurn(threadId, turn) {
         if (turn.modelMessages.length === 0)
             return okVoid();
-        return withTransaction(pool, "thread-history.appendTurn", (client) => lockThread(client, threadId, "thread-history.appendTurn")
-            .andThen(() => nextSeq(client, threadId, "thread-history.appendTurn"))
-            .andThen((startSeq) => insertGroup(client, threadId, startSeq, turn, "thread-history.appendTurn"))
-            .andThen(() => touchThread(client, threadId, "thread-history.appendTurn")));
+        return withTransaction(pool, "thread-history.appendTurn", (client) => appendTurnIn(client, threadId, turn));
     }
     function writeTurn(threadId, write) {
         const { close } = write;
         const groups = [...(write.opening === undefined ? [] : [write.opening]), ...write.rounds, ...(close?.note === undefined ? [] : [close.note])];
         return withTransaction(pool, "thread-history.writeTurn", (client) => lockThread(client, threadId, "thread-history.writeTurn")
-            .andThen(() => nextSeq(client, threadId, "thread-history.writeTurn"))
-            .andThen((firstSeq) => {
-            const startSeq = write.opening === undefined ? write.startSeq : firstSeq;
-            const steps = [];
-            let seq = firstSeq;
-            for (const [index, group] of groups.entries()) {
-                const groupSeq = seq;
-                seq += group.modelMessages.length;
-                steps.push(() => insertGroup(client, threadId, groupSeq, group, "thread-history.writeTurn"));
-                if (index === 0 && write.opening !== undefined)
-                    steps.push(() => openTurnRecord(client, threadId, startSeq));
-            }
-            if (close !== undefined)
-                steps.push(() => closeTurnRecord(client, threadId, startSeq, close));
-            steps.push(() => touchThread(client, threadId, "thread-history.writeTurn"));
-            return steps.reduce((chain, step) => chain.andThen(step), okVoid()).map(() => ({ startSeq }));
+            // One transaction stores each group of a write, thus a stored first group means a stored write.
+            .andThen(() => storedGroupSeq(client, threadId, groups[0]?.key, "thread-history.writeTurn"))
+            .andThen((storedSeq) => {
+            if (storedSeq === undefined)
+                return writeGroups(client);
+            return okAsync({ startSeq: write.opening === undefined ? write.startSeq : storedSeq });
         }));
+        function writeGroups(client) {
+            return nextSeq(client, threadId, "thread-history.writeTurn").andThen((firstSeq) => {
+                const startSeq = write.opening === undefined ? write.startSeq : firstSeq;
+                const steps = [];
+                let seq = firstSeq;
+                for (const [index, group] of groups.entries()) {
+                    const groupSeq = seq;
+                    seq += group.modelMessages.length;
+                    steps.push(() => insertGroup(client, threadId, groupSeq, group, "thread-history.writeTurn"));
+                    if (index === 0 && write.opening !== undefined)
+                        steps.push(() => openTurnRecord(client, threadId, startSeq));
+                }
+                if (close !== undefined)
+                    steps.push(() => closeTurnRecord(client, threadId, startSeq, close));
+                steps.push(() => touchThread(client, threadId, "thread-history.writeTurn"));
+                return steps.reduce((chain, step) => chain.andThen(step), okVoid()).map(() => ({ startSeq }));
+            });
+        }
     }
     function loadRecent(threadId, options) {
         return tryQuery("thread-history.loadRecent", async () => {
@@ -375,7 +394,7 @@ export function createThreadHistory(pool, logger) {
             // nothing has no rollup at all. The two are different measurements
             // sharing a unit; see the column comments.
             `SELECT seq::text AS seq, message_envelope, tokens
-         FROM messages WHERE thread_id = $1 ORDER BY messages.seq ASC`, [threadId]);
+         FROM messages WHERE thread_id = $1 AND ($2::bigint IS NULL OR messages.seq <= $2::bigint) ORDER BY messages.seq ASC`, [threadId, options?.throughSeq ?? null]);
             const parsed = rows.map((row, index) => ({
                 index,
                 message: parseStoredMessageEnvelope(row.message_envelope, `${threadId}/${row.seq}`).message,
@@ -405,25 +424,30 @@ export function createThreadHistory(pool, logger) {
     async function toStoredMessage(threadId, r) {
         const envelope = parseStoredMessageEnvelope(r.message_envelope, `${threadId}/${r.seq}`);
         const displayEnvelope = r.display_envelope == null ? undefined : await parseStoredDisplayEnvelope(r.display_envelope, `${threadId}/${r.seq}/display`, logger);
-        const turn = r.turn_status === null
-            ? undefined
-            : {
-                status: r.turn_status,
-                ...(r.turn_reason === null ? {} : { reason: r.turn_reason }),
-                ...(r.turn_usage === null ? {} : { usage: r.turn_usage }),
-                ...(r.turn_record_duration_ms === null ? {} : { durationMs: Number(r.turn_record_duration_ms) }),
-            };
-        return {
+        const row = {
             seq: Number(r.seq),
             envelope,
             message: envelope.message,
-            ...(displayEnvelope ? { displayEnvelope } : {}),
-            ...(r.reported_usage === null ? {} : { usage: r.reported_usage }),
-            ...(r.turn_duration_ms === null ? {} : { durationMs: Number(r.turn_duration_ms) }),
-            ...(turn === undefined ? {} : { turn }),
-            ...(r.author === null ? {} : { author: r.author }),
+            displayEnvelope,
             createdAt: r.created_at,
         };
+        if (r.reported_usage !== null)
+            row.usage = r.reported_usage;
+        if (r.turn_duration_ms !== null)
+            row.durationMs = Number(r.turn_duration_ms);
+        if (r.author !== null)
+            row.author = r.author;
+        if (r.turn_status !== null) {
+            const turn = { status: r.turn_status };
+            if (r.turn_reason !== null)
+                turn.reason = r.turn_reason;
+            if (r.turn_usage !== null)
+                turn.usage = r.turn_usage;
+            if (r.turn_record_duration_ms !== null)
+                turn.durationMs = Number(r.turn_record_duration_ms);
+            row.turn = turn;
+        }
+        return row;
     }
     async function toTurns(threadId, rows) {
         const stored = await Promise.all(rows.map((row) => toStoredMessage(threadId, row)));
@@ -488,7 +512,7 @@ export function createThreadHistory(pool, logger) {
                     (SELECT MAX(seq)::text FROM messages
                        WHERE thread_id = $1
                          AND ${GENUINE_USER_START_SQL}) AS boundary`, [threadId]);
-            return rows[0];
+            return presentFirst(rows, "the thread boundary row");
         }))
             .andThen(({ has_rows, boundary }) => {
             if (!has_rows)
@@ -533,7 +557,7 @@ export function createThreadHistory(pool, logger) {
         return tryQuery("thread-history.countUserTurnsAfter", () => pool.query(`SELECT COUNT(*)::text AS turns FROM messages
               WHERE thread_id = $1
                 AND seq > $2::bigint
-                AND ${GENUINE_USER_START_SQL}`, [threadId, seq])).map(({ rows }) => Number(rows[0].turns));
+                AND ${GENUINE_USER_START_SQL}`, [threadId, seq])).map(({ rows }) => Number(presentFirst(rows, "the user-turn count row").turns));
     }
     return { appendTurn, writeTurn, loadRecent, loadAll, loadPage, retractLastTurn, latestSeq, latestTurnAt, countUserTurnsAfter };
 }

package/dist/memory/thread-store.d.ts

@@ -44,8 +44,9 @@
  * so it does not enforce that.
  */
 import { type ResultAsync } from "neverthrow";
-import type { Pool } from "pg";
-import { type DbError } from "../lib/db-result.js";
+import { type DbError, type Connectable } from "../lib/db-result.js";
+import type { Querier } from "../state/db.js";
+import { type ConversationTurn } from "./thread-history.js";
 /**
  * The kind of session a thread holds. `conversation` is the analysis
  * conversation the product has always had; `report` is a report session spawned
@@ -65,7 +66,7 @@ import { type DbError } from "../lib/db-result.js";
 declare const THREAD_TYPES: readonly ["conversation", "report"];
 export type ThreadType = (typeof THREAD_TYPES)[number];
 /** One conversation thread's metadata, as returned by the store. */
-export interface Thread {
+export type Thread = {
     readonly threadId: string;
     readonly analysisId: string;
     readonly title: string | null;
@@ -93,13 +94,13 @@ export interface Thread {
      * fall through and render a tombstoned conversation as live.
      */
     readonly deletedAt: Date | null;
-}
-export interface CreateThreadInput {
+};
+export type CreateThreadInput = {
     readonly threadId: string;
     readonly analysisId: string;
     readonly title?: string | null;
-    /** Omitted is `conversation` — what a thread is when nothing says otherwise. */
-    readonly type?: ThreadType;
+    /** Omitted is `conversation` — what a thread is when nothing says otherwise. The store refuses a value outside the closed set at runtime: an untyped caller (a JSON body across a package boundary) can hand in any string, and `unknown_thread_type` is the declared refusal for it. */
+    readonly type?: string;
     /**
      * The thread this one is spawned from. It must belong to the same analysis
      * as the child; whether it exists at all is the foreign key's verdict, not
@@ -112,7 +113,13 @@ export interface CreateThreadInput {
      * and either half alone describes no place.
      */
     readonly parentSeq?: number;
-}
+    /**
+     * The first turn of the new thread. The row and the turn commit in one
+     * transaction. A create that finds the row already there writes no turn,
+     * thus a second create with the same id gives the thread with one turn.
+     */
+    readonly firstTurn?: ConversationTurn;
+};
 /**
  * A create the store refuses on its own, before any row is written. Distinct
  * from `DbError`: nothing failed at the driver — the request described a thread
@@ -143,7 +150,7 @@ export type ThreadInputError = {
     readonly threadId: string;
     readonly threadType: string;
 };
-export interface ListThreadsInput {
+export type ListThreadsInput = {
     readonly analysisId: string;
     readonly page?: number;
     readonly perPage?: number;
@@ -168,21 +175,21 @@ export interface ListThreadsInput {
     readonly type?: ThreadType;
     /** Narrow to one thread's direct children, exact match. Same polarity as `type`: omitting it narrows nothing. */
     readonly parentThreadId?: string;
-}
-export interface ListRecentThreadsInput {
+};
+export type ListRecentThreadsInput = {
     /** The most threads to give. It clamps to 1 to 200, the bounds of a page of `listThreads`. */
     readonly limit: number;
     /** Narrow to one kind of session, exact match. Omitting it narrows nothing. */
     readonly type?: ThreadType;
-}
-export interface ThreadPage {
+};
+export type ThreadPage = {
     readonly threads: Thread[];
     readonly total: number;
     readonly page: number;
     readonly perPage: number;
     readonly hasMore: boolean;
-}
-export interface ThreadStore {
+};
+export type ThreadStore = {
     /**
      * Create a thread row. Idempotent on `thread_id` — a second create for an
      * existing id is a no-op that preserves the existing row (including its
@@ -260,11 +267,13 @@ export interface ThreadStore {
      * archived thread is never in it.
      */
     listRecentThreads(input: ListRecentThreadsInput): ResultAsync<Thread[], DbError>;
-}
+};
 /**
  * Create a `ThreadStore` bound to a Postgres pool — a factory closure
  * capturing `pool` (dependency injection per the harness-durable-runtime spec). The
  * `cortex_analysis_threads` table is provisioned by the state-init DDL.
  */
-export declare function createThreadStore(pool: Pool): ThreadStore;
+/** What this module reads of the pool: the direct `query` plus the transactional `connect`. */
+type ThreadStorePool = Querier & Connectable;
+export declare function createThreadStore(pool: ThreadStorePool): ThreadStore;
 export {};

package/dist/memory/thread-store.js

@@ -45,6 +45,8 @@
  */
 import { errAsync, okAsync } from "neverthrow";
 import { tryMutation, tryQuery, withTransaction } from "../lib/db-result.js";
+import { presentFirst } from "../lib/present.js";
+import { appendTurnIn } from "./thread-history.js";
 /**
  * The kind of session a thread holds. `conversation` is the analysis
  * conversation the product has always had; `report` is a report session spawned
@@ -106,11 +108,6 @@ function toThread(row) {
 }
 const DEFAULT_PER_PAGE = 100;
 const MAX_PER_PAGE = 200;
-/**
- * Create a `ThreadStore` bound to a Postgres pool — a factory closure
- * capturing `pool` (dependency injection per the harness-durable-runtime spec). The
- * `cortex_analysis_threads` table is provisioned by the state-init DDL.
- */
 export function createThreadStore(pool) {
     /**
      * The parent's own analysis scope, or `null` when no such row exists.
@@ -141,16 +138,22 @@ export function createThreadStore(pool) {
      * returned row.
      */
     function insertThread(input) {
-        return tryMutation("thread-store.createThread.insert", () => pool.query(`INSERT INTO cortex_analysis_threads (thread_id, analysis_id, title, thread_type, parent_thread_id, parent_seq)
+        const { firstTurn } = input;
+        if (firstTurn === undefined)
+            return insertRow(pool, input).map(({ thread }) => thread);
+        return withTransaction(pool, "thread-store.createThread", (client) => insertRow(client, input).andThen(({ thread, inserted }) => inserted ? appendTurnIn(client, thread.threadId, firstTurn).map(() => thread) : okAsync(thread)));
+    }
+    function insertRow(querier, input) {
+        return tryMutation("thread-store.createThread.insert", () => querier.query(`INSERT INTO cortex_analysis_threads (thread_id, analysis_id, title, thread_type, parent_thread_id, parent_seq)
          VALUES ($1, $2, $3, $4, $5, $6)
          ON CONFLICT (thread_id) DO NOTHING
          RETURNING ${THREAD_COLUMNS}`, [input.threadId, input.analysisId, input.title ?? null, input.type ?? "conversation", input.parentThreadId ?? null, input.parentSeq ?? null])).andThen(({ rows }) => {
             if (rows[0])
-                return okAsync(toThread(rows[0]));
+                return okAsync({ thread: toThread(rows[0]), inserted: true });
             // Row already existed — ON CONFLICT DO NOTHING returns nothing. Read it
             // back (it may be archived; return it regardless so the caller sees
             // the existing row's identity).
-            return tryQuery("thread-store.createThread.readback", () => pool.query(`SELECT ${THREAD_COLUMNS} FROM cortex_analysis_threads WHERE thread_id = $1`, [input.threadId])).map(({ rows: existing }) => toThread(existing[0]));
+            return tryQuery("thread-store.createThread.readback", () => querier.query(`SELECT ${THREAD_COLUMNS} FROM cortex_analysis_threads WHERE thread_id = $1`, [input.threadId])).map(({ rows: existing }) => ({ thread: toThread(presentFirst(existing, "the thread row read back")), inserted: false }));
         });
     }
     function createThread(input) {
@@ -289,6 +292,7 @@ export function createThreadStore(pool) {
         // `cortex_analysis_threads` either, so the cascade cannot reach it. Its row
         // holds a whole draft document, and a purged thread can never be composed
         // again, so a row left behind is dead weight until the analysis purge runs.
+        // The stored results of its authoring calls go with it, for the same reason.
         //
         // Messages go first, and the thread rows go last: the walk every statement
         // shares reads the very rows the last one removes. Thus a thread delete before
@@ -305,6 +309,8 @@ export function createThreadStore(pool) {
          DELETE FROM cortex_thread_turns WHERE thread_id IN (SELECT thread_id FROM subtree)`, [threadId])))
             .andThen(() => tryMutation("thread-store.purgeThread.reportSessionState", () => client.query(`${SUBTREE_CTE}
          DELETE FROM cortex_report_session_state WHERE thread_id IN (SELECT thread_id FROM subtree)`, [threadId])))
+            .andThen(() => tryMutation("thread-store.purgeThread.authoringResults", () => client.query(`${SUBTREE_CTE}
+         DELETE FROM cortex_authoring_results WHERE thread_id IN (SELECT thread_id FROM subtree)`, [threadId])))
             // A kept text of a run names no thread, thus it stays for the analysis purge.
             .andThen(() => tryMutation("thread-store.purgeThread.toolOutputs", () => client.query(`${SUBTREE_CTE}
          DELETE FROM cortex_tool_outputs WHERE thread_id IN (SELECT thread_id FROM subtree)`, [threadId])))
@@ -352,7 +358,7 @@ export function createThreadStore(pool) {
         return tryQuery("thread-store.listThreads.count", () => pool.query(`SELECT COUNT(*)::text AS count
          FROM cortex_analysis_threads
          WHERE ${scope}`, scopeValues)).andThen((totalResult) => {
-            const total = Number(totalResult.rows[0].count);
+            const total = Number(presentFirst(totalResult.rows, "the thread count row").count);
             return tryQuery("thread-store.listThreads.page", () => pool.query(`SELECT ${THREAD_COLUMNS}
            FROM cortex_analysis_threads
            WHERE ${scope}

package/dist/memory/tool-call-integrity.d.ts

@@ -18,10 +18,10 @@ import type { ModelMessage, ToolCallPart, ToolResultPart } from "ai";
 export declare const NOT_RUN_TOOL_RESULT = "Not run: the turn ended before this call ran.";
 export declare function notRunResult(call: Pick<ToolCallPart, "toolCallId" | "toolName">): ToolResultPart;
 /** One tool call that {@link answerUnansweredToolCalls} answered, identified for the caller's diagnostic record. */
-export interface AnsweredToolCall {
+export type AnsweredToolCall = {
     readonly toolCallId: string;
     readonly toolName: string;
-}
+};
 /**
  * Answer, in place, every tool call at or past `fromIndex` that has no matching
  * tool result anywhere in `messages`. No message is removed or changed. Returns

package/dist/memory/tool-call-integrity.js

@@ -14,6 +14,7 @@
  * because a signed thinking block and the prompt cache both key on the exact
  * prior prefix.
  */
+import { presentAt } from "../lib/present.js";
 export const NOT_RUN_TOOL_RESULT = "Not run: the turn ended before this call ran.";
 export function notRunResult(call) {
     return {
@@ -67,14 +68,14 @@ export function answerUnansweredToolCalls(messages, fromIndex = 0) {
     // Backward, so an insertion after a message cannot shift an index this walk
     // has yet to visit.
     for (let idx = messages.length - 1; idx >= fromIndex; idx--) {
-        const message = messages[idx];
+        const message = presentAt(messages, idx, "the message at the index");
         if (message.role !== "assistant" || typeof message.content === "string")
             continue;
-        const unanswered = message.content.filter((part) => part.type === "tool-call" && needsClientResult(part) && !resultIds.has(part.toolCallId));
+        const unanswered = message.content.flatMap((part) => part.type === "tool-call" && needsClientResult(part) && !resultIds.has(part.toolCallId) ? [part] : []);
         if (unanswered.length === 0)
             continue;
         let insertAt = idx + 1;
-        while (insertAt < messages.length && messages[insertAt].role === "tool")
+        while (insertAt < messages.length && presentAt(messages, insertAt, "the message at the insert point").role === "tool")
             insertAt++;
         messages.splice(insertAt, 0, { role: "tool", content: unanswered.map((part) => notRunResult(part)) });
         // Prepended as a batch: the walk visits messages tail-first, but the

package/dist/memory/working-memory.d.ts

@@ -28,9 +28,9 @@
  *    list; the run's detail stays retrievable via `inspect_run`.
  */
 import { type ResultAsync } from "neverthrow";
-import type { Pool } from "pg";
 import { z } from "zod";
-import { type DbError } from "../lib/db-result.js";
+import { type Connectable, type DbError } from "../lib/db-result.js";
+import type { Querier } from "../state/db.js";
 /**
  * The write-time bounds on working memory. `updateSection` enforces them, the
  * `update_working_memory` input schema declares them to the model (importing
@@ -53,8 +53,8 @@ export declare const constraintSchema: z.ZodObject<{
     id: z.ZodString;
     text: z.ZodString;
     origin: z.ZodEnum<{
-        user: "user";
         agent: "agent";
+        user: "user";
     }>;
 }, z.core.$strip>;
 export type Constraint = z.infer<typeof constraintSchema>;
@@ -85,8 +85,8 @@ export declare const workingMemorySchema: z.ZodObject<{
         id: z.ZodString;
         text: z.ZodString;
         origin: z.ZodEnum<{
-            user: "user";
             agent: "agent";
+            user: "user";
         }>;
     }, z.core.$strip>>;
     hypotheses: z.ZodArray<z.ZodObject<{
@@ -107,10 +107,10 @@ export declare function emptyWorkingMemory(): WorkingMemory;
  * written for the model and says what to do next (shorten this, retire that).
  * The tool surfaces it as an `is_error` tool result; the row is untouched.
  */
-export interface WorkingMemoryRejection {
+export type WorkingMemoryRejection = {
     readonly type: "working_memory_rejected";
     readonly message: string;
-}
+};
 /** `updateSection`'s error channel: a storage failure, or a refused write. */
 export type WorkingMemoryError = DbError | WorkingMemoryRejection;
 /** Narrow a `WorkingMemoryError` to the model-correctable branch. */
@@ -162,21 +162,21 @@ export type FindingOp = {
     readonly id: string;
 };
 /** The `value` argument of `updateSection`, keyed by the `section` name. */
-export interface SectionValue {
+export type SectionValue = {
     readonly goal: {
         readonly text: string;
     };
     readonly constraint: ConstraintOp;
     readonly hypothesis: ListOp;
     readonly finding: FindingOp;
-}
+};
 export type Section = keyof SectionValue;
 /**
  * The working-memory store. Three methods — `load` reads the structured
  * shape, `updateSection` amends one section, `render` serializes to the
  * Markdown the chat route injects.
  */
-export interface WorkingMemoryStore {
+export type WorkingMemoryStore = {
     /** Read the row; return the empty shape if absent (no lazy insert). */
     load(analysisId: string): ResultAsync<WorkingMemory, DbError>;
     /**
@@ -184,11 +184,15 @@ export interface WorkingMemoryStore {
      * left byte-identical; the row is upserted if absent. A write that breaks a
      * cap or addresses an unknown id is refused — `err(WorkingMemoryRejection)`,
      * and the row is left exactly as it was.
+     *
+     * `callKey` names the durable step of the call. The edit records it in its
+     * own transaction, and an edit whose key is recorded already changes nothing
+     * and gives ok. Thus a rerun of the step applies the edit one time.
      */
-    updateSection<S extends Section>(analysisId: string, section: S, value: SectionValue[S]): ResultAsync<void, WorkingMemoryError>;
+    updateSection<S extends Section>(analysisId: string, section: S, value: SectionValue[S], callKey?: string): ResultAsync<void, WorkingMemoryError>;
     /** Serialize working memory to a Markdown document for injection. */
     render(analysisId: string): ResultAsync<string, DbError>;
-}
+};
 /**
  * Serialize working memory to the Markdown document of the working-memory context record.
  *
@@ -212,4 +216,4 @@ export declare function renderWorkingMemory(wm: WorkingMemory): string;
  * `cortex_working_memory` table is provisioned by the project's state-init
  * DDL.
  */
-export declare function createWorkingMemory(pool: Pool): WorkingMemoryStore;
+export declare function createWorkingMemory(pool: Querier & Connectable): WorkingMemoryStore;