agents 0.27.0 → 0.28.1

package/dist/harness/think/index.js

@@ -1,11 +1,12 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../../classPrivateFieldGet2-DZBYAB34.js";
 import { t as _classPrivateMethodInitSpec } from "../../classPrivateMethodInitSpec-qMjJ6sHQ.js";
-import { n as bindLifecycleCapability, t as LifecycleCapability } from "../../capability-B4WbF81e.js";
+import { n as bindLifecycleCapability, t as LifecycleCapability } from "../../capability-DBAKc6UZ.js";
 import { n as STREAM_RESUME_NONE_REASONS, r as StreamAccumulator, t as CHAT_MESSAGE_TYPES } from "../../protocol-eXeJxhgu.js";
-import { n as Streams } from "../../streams-CITClVer.js";
+import { n as Streams } from "../../streams-lsHMJhRW.js";
 import { i as createToolsFromClientSchemas, n as iterateWithStallWatchdog, r as parseProtocolMessage, t as ChatStreamStalledError } from "../../stall-watchdog-BpRF2uwG.js";
-import { t as Sessions } from "../../sessions-B9pNuxdT.js";
+import { t as Sessions } from "../../sessions-_vN5BEZX.js";
 import { a as toTranscriptMessage, r as toResponseChunk, t as answerToolCall } from "../../turns-DCV3ycDl.js";
+import { n as openHarnessStore } from "../../store-CslVzfN7.js";
 import { convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
 //#region src/harness/think/events.ts
 var _listeners = /* @__PURE__ */ new WeakMap();
@@ -111,193 +112,388 @@ async function _drain() {
 }
 //#endregion
 //#region src/harness/think/records.ts
-const STATUSES = /* @__PURE__ */ new Set([
-	"queued",
-	"running",
-	"done",
-	"unanswered"
-]);
-function parseStatus(value) {
-	if (!STATUSES.has(value)) throw new Error(`Unknown ThinkHarness operation status ${value}`);
+/** The shared store's table prefix for ThinkHarness's records. */
+const STORE_PREFIX = "cf_think_harness_store_";
+/** The tables ThinkHarness kept its records in before the shared store. */
+const LEGACY_SESSIONS = "cf_think_harness_sessions";
+const LEGACY_OPERATIONS = "cf_think_harness_operations";
+const LEGACY_TOOL_CALLS = "cf_think_harness_tool_calls";
+const OPEN$1 = ["queued", "running"];
+const EMPTY_STATE = {
+	clientTools: [],
+	toolCalls: {}
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringOrNull(value) {
+	return typeof value === "string" ? value : null;
+}
+function count(value) {
+	return typeof value === "number" ? value : 0;
+}
+function parseMeta(value) {
+	const fields = isRecord$1(value) ? value : {};
+	return {
+		source: fields.source === "client" ? "client" : "server",
+		parentId: stringOrNull(fields.parentId),
+		messageId: stringOrNull(fields.messageId),
+		streamId: stringOrNull(fields.streamId),
+		pendingModel: fields.pendingModel === true,
+		steps: count(fields.steps),
+		interruptions: count(fields.interruptions),
+		overflowRetries: count(fields.overflowRetries),
+		abandonReason: stringOrNull(fields.abandonReason)
+	};
+}
+function newMeta(source) {
+	return {
+		source,
+		parentId: null,
+		messageId: null,
+		streamId: null,
+		pendingModel: false,
+		steps: 0,
+		interruptions: 0,
+		overflowRetries: 0,
+		abandonReason: null
+	};
+}
+function metaJson(meta) {
+	return { ...meta };
+}
+function withProgress(meta, change) {
+	return {
+		source: meta.source,
+		parentId: change.parentId === void 0 ? meta.parentId : change.parentId,
+		messageId: change.messageId === void 0 ? meta.messageId : change.messageId,
+		streamId: change.streamId === void 0 ? meta.streamId : change.streamId,
+		pendingModel: change.pendingModel ?? meta.pendingModel,
+		steps: change.steps ?? meta.steps,
+		interruptions: change.interruptions ?? meta.interruptions,
+		overflowRetries: change.overflowRetries ?? meta.overflowRetries,
+		abandonReason: change.abandonReason === void 0 ? meta.abandonReason : change.abandonReason
+	};
+}
+function inputJson(input) {
+	return input;
+}
+function parseInput(value) {
 	return value;
 }
-function parseOperation(row) {
-	const input = JSON.parse(row.input);
+function parseText(result) {
+	return isRecord$1(result) && typeof result.text === "string" ? result.text : void 0;
+}
+function parseSessionState(value) {
+	if (!isRecord$1(value)) return EMPTY_STATE;
+	const toolCalls = Object.create(null);
+	const calls = value.toolCalls;
+	if (isRecord$1(calls)) {
+		for (const [toolCallId, call] of Object.entries(calls)) if (isRecord$1(call) && typeof call.operationId === "string" && typeof call.attempts === "number") toolCalls[toolCallId] = {
+			operationId: call.operationId,
+			attempts: call.attempts
+		};
+	}
 	return {
-		session: row.session_id,
-		operationId: row.operation_id,
-		seq: row.seq,
-		input,
-		status: parseStatus(row.status),
-		source: row.source === "client" ? "client" : "server",
-		parentId: row.parent_id ?? void 0,
-		messageId: row.message_id ?? void 0,
-		streamId: row.stream_id ?? void 0,
-		pendingModel: row.pending_model === 1,
-		steps: row.steps,
-		interruptions: row.interruptions,
-		overflowRetries: row.overflow_retries,
-		reason: row.reason ?? void 0,
-		text: row.text ?? void 0,
-		abandonReason: row.abandon_reason ?? void 0,
-		createdAt: row.created_at
+		clientTools: Array.isArray(value.clientTools) ? value.clientTools : [],
+		toolCalls
+	};
+}
+function sessionStateJson(state) {
+	return {
+		clientTools: state.clientTools,
+		toolCalls: { ...state.toolCalls }
 	};
 }
-var _sql = /* @__PURE__ */ new WeakMap();
-var _ready = /* @__PURE__ */ new WeakMap();
+function parseOperation(stored) {
+	const meta = parseMeta(stored.meta);
+	return {
+		session: stored.session,
+		operationId: stored.id,
+		seq: stored.seq,
+		input: parseInput(stored.input),
+		status: stored.status,
+		source: meta.source,
+		parentId: meta.parentId ?? void 0,
+		messageId: meta.messageId ?? void 0,
+		streamId: meta.streamId ?? void 0,
+		pendingModel: meta.pendingModel,
+		steps: meta.steps,
+		interruptions: meta.interruptions,
+		overflowRetries: meta.overflowRetries,
+		reason: stored.reason,
+		text: stored.status === "done" ? parseText(stored.result) : void 0,
+		abandonReason: meta.abandonReason ?? void 0,
+		createdAt: stored.createdAt
+	};
+}
+var _store = /* @__PURE__ */ new WeakMap();
+var _OperationRecords_brand = /* @__PURE__ */ new WeakSet();
 /**
-* The harness's own tables, over the object's SQLite: sessions, the
-* operation queue, and started tool calls. Named apart from the shared
-* `agents/harness/store`, which is a different, harness-agnostic store.
+* The harness's records, over the shared harness store: sessions, the
+* operation queue, and started tool calls. Opening it moves records an
+* earlier version left in its own tables into the store.
 */
 var OperationRecords = class {
-	constructor(sql) {
-		_classPrivateFieldInitSpec(this, _sql, void 0);
-		_classPrivateFieldInitSpec(this, _ready, false);
-		_classPrivateFieldSet2(_sql, this, sql);
-	}
-	/** Create the tables. Idempotent. */
-	ensureTables() {
-		if (_classPrivateFieldGet2(_ready, this)) return;
-		_classPrivateFieldGet2(_sql, this).exec(`CREATE TABLE IF NOT EXISTS cf_think_harness_sessions (
-      id TEXT PRIMARY KEY,
-      parent TEXT,
-      client_tools TEXT,
-      created_at INTEGER NOT NULL
-    )`);
-		_classPrivateFieldGet2(_sql, this).exec(`CREATE TABLE IF NOT EXISTS cf_think_harness_operations (
-      session_id TEXT NOT NULL,
-      operation_id TEXT NOT NULL,
-      seq INTEGER NOT NULL,
-      input TEXT NOT NULL,
-      status TEXT NOT NULL,
-      source TEXT NOT NULL,
-      parent_id TEXT,
-      message_id TEXT,
-      stream_id TEXT,
-      pending_model INTEGER NOT NULL DEFAULT 0,
-      steps INTEGER NOT NULL DEFAULT 0,
-      interruptions INTEGER NOT NULL DEFAULT 0,
-      overflow_retries INTEGER NOT NULL DEFAULT 0,
-      reason TEXT,
-      text TEXT,
-      abandon_reason TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      PRIMARY KEY (session_id, operation_id)
-    )`);
-		if (!new Set(_classPrivateFieldGet2(_sql, this).exec(`PRAGMA table_info(cf_think_harness_operations)`).toArray().map((column) => column.name)).has("abandon_reason")) _classPrivateFieldGet2(_sql, this).exec(`ALTER TABLE cf_think_harness_operations ADD COLUMN abandon_reason TEXT`);
-		_classPrivateFieldGet2(_sql, this).exec(`CREATE INDEX IF NOT EXISTS cf_think_harness_operations_open
-      ON cf_think_harness_operations (session_id, status, seq)`);
-		_classPrivateFieldGet2(_sql, this).exec(`CREATE TABLE IF NOT EXISTS cf_think_harness_tool_calls (
-      session_id TEXT NOT NULL,
-      tool_call_id TEXT NOT NULL,
-      operation_id TEXT NOT NULL,
-      attempts INTEGER NOT NULL,
-      PRIMARY KEY (session_id, tool_call_id)
-    )`);
-		_classPrivateFieldSet2(_ready, this, true);
-	}
-	/** Record a session, unless it exists. Returns whether it was new. */
+	/**
+	* Open the records, creating the store's tables and importing any legacy
+	* tables. Cheap after the first time: keep one per isolate.
+	*
+	* @param storage - The Durable Object's storage.
+	*/
+	constructor(storage) {
+		_classPrivateMethodInitSpec(this, _OperationRecords_brand);
+		_classPrivateFieldInitSpec(this, _store, void 0);
+		_classPrivateFieldSet2(_store, this, openHarnessStore(storage, { prefix: STORE_PREFIX }));
+		importLegacyTables(storage, _classPrivateFieldGet2(_store, this));
+	}
+	/** Record a session, unless it exists. */
 	ensureSession(id, parent) {
-		return _classPrivateFieldGet2(_sql, this).exec(`INSERT OR IGNORE INTO cf_think_harness_sessions (id, parent, created_at)
-       VALUES (?, ?, ?)`, id, parent ?? null, Date.now()).rowsWritten > 0;
+		_classPrivateFieldGet2(_store, this).createSession({
+			id,
+			...parent !== void 0 && { parent },
+			state: sessionStateJson(EMPTY_STATE)
+		});
 	}
 	/** Every session, oldest first. */
 	sessions() {
-		return _classPrivateFieldGet2(_sql, this).exec(`SELECT id, parent, client_tools, created_at
-         FROM cf_think_harness_sessions ORDER BY created_at, id`).toArray().map((row) => ({
-			id: row.id,
-			parent: row.parent ?? void 0,
-			createdAt: row.created_at
+		return _classPrivateFieldGet2(_store, this).sessions().map((session) => ({
+			id: session.id,
+			parent: session.parent,
+			createdAt: session.createdAt
 		}));
 	}
 	/** The client tools a session's client last declared. */
 	clientTools(session) {
-		const row = _classPrivateFieldGet2(_sql, this).exec(`SELECT client_tools FROM cf_think_harness_sessions WHERE id = ?`, session).toArray()[0];
-		if (!row?.client_tools) return [];
-		return JSON.parse(row.client_tools);
+		return [..._assertClassBrand(_OperationRecords_brand, this, _state).call(this, session).clientTools];
 	}
 	/** Replace the client tools a session's client declared. */
 	setClientTools(session, tools) {
-		_classPrivateFieldGet2(_sql, this).exec(`UPDATE cf_think_harness_sessions SET client_tools = ? WHERE id = ?`, JSON.stringify(tools), session);
+		_assertClassBrand(_OperationRecords_brand, this, _updateState).call(this, session, (state) => ({
+			...state,
+			clientTools: tools
+		}));
 	}
 	/** Insert a queued operation. Returns false when the id already exists. */
 	insert(session, operationId, input, source) {
-		const now = Date.now();
-		return _classPrivateFieldGet2(_sql, this).exec(`INSERT OR IGNORE INTO cf_think_harness_operations
-           (session_id, operation_id, seq, input, status, source, created_at, updated_at)
-         VALUES (?, ?,
-           (SELECT COALESCE(MAX(seq), 0) + 1 FROM cf_think_harness_operations),
-           ?, 'queued', ?, ?, ?)`, session, operationId, JSON.stringify(input), source, now, now).rowsWritten > 0;
+		return _classPrivateFieldGet2(_store, this).enqueue({
+			session,
+			id: operationId,
+			input: inputJson(input),
+			meta: metaJson(newMeta(source))
+		}).accepted;
 	}
 	/** One operation. */
 	get(session, operationId) {
-		const row = _classPrivateFieldGet2(_sql, this).exec(`SELECT * FROM cf_think_harness_operations
-         WHERE session_id = ? AND operation_id = ?`, session, operationId).toArray()[0];
-		return row ? parseOperation(row) : void 0;
+		const stored = _classPrivateFieldGet2(_store, this).operation(session, operationId);
+		return stored ? parseOperation(stored) : void 0;
 	}
 	/** Unsettled operations, oldest first; every session when none is given. */
 	open(session) {
-		return (session === void 0 ? _classPrivateFieldGet2(_sql, this).exec(`SELECT * FROM cf_think_harness_operations
-             WHERE status IN ('queued', 'running') ORDER BY seq`) : _classPrivateFieldGet2(_sql, this).exec(`SELECT * FROM cf_think_harness_operations
-             WHERE session_id = ? AND status IN ('queued', 'running')
-             ORDER BY seq`, session)).toArray().map(parseOperation);
+		return _classPrivateFieldGet2(_store, this).operations({
+			...session !== void 0 && { session },
+			status: OPEN$1
+		}).map(parseOperation);
 	}
-	/** Apply a change to an operation's fields. */
+	/** Change an operation's progress. */
 	update(session, operationId, change) {
-		const sets = [];
-		const values = [];
-		const set = (column, value) => {
-			sets.push(`${column} = ?`);
-			values.push(value);
-		};
-		if (change.status !== void 0) set("status", change.status);
-		if (change.parentId !== void 0) set("parent_id", change.parentId);
-		if (change.messageId !== void 0) set("message_id", change.messageId);
-		if (change.streamId !== void 0) set("stream_id", change.streamId);
-		if (change.pendingModel !== void 0) set("pending_model", change.pendingModel ? 1 : 0);
-		if (change.steps !== void 0) set("steps", change.steps);
-		if (change.interruptions !== void 0) set("interruptions", change.interruptions);
-		if (change.overflowRetries !== void 0) set("overflow_retries", change.overflowRetries);
-		if (change.reason !== void 0) set("reason", change.reason);
-		if (change.text !== void 0) set("text", change.text);
-		if (change.abandonReason !== void 0) set("abandon_reason", change.abandonReason);
-		set("updated_at", Date.now());
-		_classPrivateFieldGet2(_sql, this).exec(`UPDATE cf_think_harness_operations SET ${sets.join(", ")}
-       WHERE session_id = ? AND operation_id = ?`, ...values, session, operationId);
+		_classPrivateFieldGet2(_store, this).transaction(() => {
+			const stored = _classPrivateFieldGet2(_store, this).operation(session, operationId);
+			if (!stored) return;
+			_classPrivateFieldGet2(_store, this).setOperationMeta(session, operationId, metaJson(withProgress(parseMeta(stored.meta), change)));
+		});
+	}
+	/**
+	* Move a queued operation to running, with its progress so far.
+	* Returns false when it was not queued.
+	*/
+	start(session, operationId, change) {
+		return _classPrivateFieldGet2(_store, this).transaction(() => {
+			if (!_classPrivateFieldGet2(_store, this).start(session, operationId)) return false;
+			this.update(session, operationId, change);
+			return true;
+		});
+	}
+	/**
+	* Settle an open operation, with a last change to its progress. Returns
+	* false when it had already settled.
+	*/
+	settle(session, operationId, outcome, change = {}) {
+		return _classPrivateFieldGet2(_store, this).transaction(() => {
+			const settled = _classPrivateFieldGet2(_store, this).settle(session, operationId, outcome.status === "done" ? {
+				status: "done",
+				result: { text: outcome.text }
+			} : outcome);
+			if (settled) this.update(session, operationId, change);
+			return settled;
+		});
 	}
 	/** Forget every settled operation in a session, for a reset. */
 	deleteSettled(session) {
-		_classPrivateFieldGet2(_sql, this).exec(`DELETE FROM cf_think_harness_operations
-       WHERE session_id = ? AND status IN ('done', 'unanswered')`, session);
-		_classPrivateFieldGet2(_sql, this).exec(`DELETE FROM cf_think_harness_tool_calls WHERE session_id = ?`, session);
+		_classPrivateFieldGet2(_store, this).transaction(() => {
+			_classPrivateFieldGet2(_store, this).deleteSettled(session);
+			_assertClassBrand(_OperationRecords_brand, this, _updateState).call(this, session, (state) => ({
+				...state,
+				toolCalls: {}
+			}));
+		});
 	}
 	/** The record of a started tool call, if it was started. */
 	toolCall(session, toolCallId) {
-		const row = _classPrivateFieldGet2(_sql, this).exec(`SELECT * FROM cf_think_harness_tool_calls
-         WHERE session_id = ? AND tool_call_id = ?`, session, toolCallId).toArray()[0];
-		return row ? {
-			session: row.session_id,
-			toolCallId: row.tool_call_id,
-			operationId: row.operation_id,
-			attempts: row.attempts
-		} : void 0;
+		const { toolCalls } = _assertClassBrand(_OperationRecords_brand, this, _state).call(this, session);
+		if (!Object.hasOwn(toolCalls, toolCallId)) return void 0;
+		const call = toolCalls[toolCallId];
+		return call && {
+			session,
+			toolCallId,
+			...call
+		};
 	}
 	/** Record that a tool call is starting. Returns the attempt number. */
 	startToolCall(session, toolCallId, operationId) {
 		const attempts = (this.toolCall(session, toolCallId)?.attempts ?? 0) + 1;
-		_classPrivateFieldGet2(_sql, this).exec(`INSERT OR REPLACE INTO cf_think_harness_tool_calls
-         (session_id, tool_call_id, operation_id, attempts)
-       VALUES (?, ?, ?, ?)`, session, toolCallId, operationId, attempts);
+		_assertClassBrand(_OperationRecords_brand, this, _updateState).call(this, session, (state) => ({
+			...state,
+			toolCalls: {
+				...state.toolCalls,
+				[toolCallId]: {
+					operationId,
+					attempts
+				}
+			}
+		}));
 		return attempts;
 	}
 	/** Forget a tool call once its result is in the transcript. */
 	finishToolCall(session, toolCallId) {
-		_classPrivateFieldGet2(_sql, this).exec(`DELETE FROM cf_think_harness_tool_calls
-       WHERE session_id = ? AND tool_call_id = ?`, session, toolCallId);
+		_assertClassBrand(_OperationRecords_brand, this, _updateState).call(this, session, (state) => {
+			const { [toolCallId]: _finished, ...toolCalls } = state.toolCalls;
+			return {
+				...state,
+				toolCalls
+			};
+		});
 	}
 };
+function _state(session) {
+	return parseSessionState(_classPrivateFieldGet2(_store, this).session(session)?.state);
+}
+function _updateState(session, change) {
+	_classPrivateFieldGet2(_store, this).transaction(() => {
+		const stored = _classPrivateFieldGet2(_store, this).session(session);
+		if (!stored) return;
+		_classPrivateFieldGet2(_store, this).setSessionState(session, sessionStateJson(change(parseSessionState(stored.state))));
+	});
+}
+function parseJsonColumn(text) {
+	return JSON.parse(text);
+}
+/**
+* Move the records an earlier version kept in its own tables into the
+* store, then drop those tables, in one transaction: either every record
+* moves or none does and the next start tries again. Operations keep their
+* order, status and progress; sessions keep their creation time, client
+* tools and started tool calls, so an operation that was in flight resumes
+* and recovers as it would have.
+*/
+function importLegacyTables(storage, store) {
+	const sql = storage.sql;
+	const present = new Set(sql.exec(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (?, ?, ?)`, LEGACY_SESSIONS, LEGACY_OPERATIONS, LEGACY_TOOL_CALLS).toArray().map((row) => row.name));
+	if (present.size === 0) return;
+	storage.transactionSync(() => {
+		const states = /* @__PURE__ */ new Map();
+		if (present.has(LEGACY_SESSIONS)) {
+			const rows = sql.exec(`SELECT id, parent, client_tools, created_at FROM ${LEGACY_SESSIONS}
+           ORDER BY created_at, id`).toArray();
+			for (const row of rows) {
+				store.createSession({
+					id: row.id,
+					...row.parent !== null && { parent: row.parent },
+					createdAt: row.created_at
+				});
+				states.set(row.id, parseSessionState({
+					clientTools: row.client_tools === null ? [] : parseJsonColumn(row.client_tools),
+					toolCalls: {}
+				}));
+			}
+		}
+		if (present.has(LEGACY_TOOL_CALLS)) {
+			const rows = sql.exec(`SELECT session_id, tool_call_id, operation_id, attempts
+           FROM ${LEGACY_TOOL_CALLS}`).toArray();
+			for (const row of rows) {
+				const state = states.get(row.session_id) ?? EMPTY_STATE;
+				states.set(row.session_id, {
+					...state,
+					toolCalls: {
+						...state.toolCalls,
+						[row.tool_call_id]: {
+							operationId: row.operation_id,
+							attempts: row.attempts
+						}
+					}
+				});
+			}
+		}
+		for (const [id, state] of states) {
+			store.createSession({ id });
+			store.setSessionState(id, sessionStateJson(state));
+		}
+		if (present.has(LEGACY_OPERATIONS)) {
+			const rows = sql.exec(`SELECT * FROM ${LEGACY_OPERATIONS} ORDER BY seq`).toArray();
+			for (const row of rows) importLegacyOperation(store, row);
+		}
+		for (const table of [
+			LEGACY_SESSIONS,
+			LEGACY_OPERATIONS,
+			LEGACY_TOOL_CALLS
+		]) sql.exec(`DROP TABLE IF EXISTS ${table}`);
+	});
+}
+function importLegacyOperation(store, row) {
+	const session = row.session_id;
+	const id = row.operation_id;
+	if (!store.session(session)) store.createSession({
+		id: session,
+		state: sessionStateJson(EMPTY_STATE)
+	});
+	const meta = {
+		source: row.source === "client" ? "client" : "server",
+		parentId: row.parent_id,
+		messageId: row.message_id,
+		streamId: row.stream_id,
+		pendingModel: row.pending_model === 1,
+		steps: row.steps,
+		interruptions: row.interruptions,
+		overflowRetries: row.overflow_retries,
+		abandonReason: row.abandon_reason ?? null
+	};
+	store.deleteOperation(session, id);
+	store.enqueue({
+		session,
+		id,
+		input: parseJsonColumn(row.input),
+		meta: metaJson(meta)
+	});
+	switch (row.status) {
+		case "queued": return;
+		case "running":
+			store.start(session, id);
+			return;
+		case "done":
+			store.settle(session, id, {
+				status: "done",
+				result: { text: row.text ?? "" }
+			});
+			return;
+		case "unanswered":
+			store.settle(session, id, {
+				status: "unanswered",
+				reason: row.reason ?? "unanswered"
+			});
+			return;
+		default: throw new Error(`Unknown ThinkHarness operation status ${row.status} in ${LEGACY_OPERATIONS}`);
+	}
+}
 //#endregion
 //#region src/harness/think/tools.ts
 /** The model-facing copy of a tool set, restricted to `activeTools` if given. */
@@ -753,7 +949,7 @@ var ThinkHarness = class extends LifecycleCapability {
 			const live = _classPrivateFieldGet2(_live, this).get(session);
 			if (live?.operationId === op.operationId) live.abort.abort();
 			else if (op.status === "queued") {
-				store.update(session, op.operationId, {
+				store.settle(session, op.operationId, {
 					status: "unanswered",
 					reason: "withdrawn"
 				});
@@ -1081,7 +1277,7 @@ async function _steps(session, operationId, live) {
 			case "await-input":
 			case "end":
 				await _assertClassBrand(_ThinkHarness_brand, this, _commit).call(this, session, void 0, () => {
-					_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, {
+					_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).settle(session, operationId, {
 						status: "done",
 						text: textOf(message)
 					});
@@ -1104,8 +1300,7 @@ async function _place(op) {
 	const placed = [];
 	let settledText;
 	let unanswered;
-	const running = (change) => store.update(session, operationId, {
-		status: "running",
+	const running = (change) => store.start(session, operationId, {
 		parentId: change.parentId ?? null,
 		messageId: change.messageId,
 		pendingModel: true
@@ -1170,7 +1365,7 @@ async function _place(op) {
 				put(answered);
 				placed.push(answered);
 				if (continues) running({ messageId: answered.id });
-				else store.update(session, operationId, {
+				else store.settle(session, operationId, {
 					status: "done",
 					text: textOf(answered)
 				});
@@ -1210,7 +1405,7 @@ async function _place(op) {
 		operationId
 	});
 	if (unanswered !== void 0) {
-		store.update(session, operationId, {
+		store.settle(session, operationId, {
 			status: "unanswered",
 			reason: unanswered
 		});
@@ -1350,11 +1545,10 @@ async function _callModel(op, existing, tools, live) {
 	if (live.abort.signal.aborted) {
 		await _assertClassBrand(_ThinkHarness_brand, this, _commit).call(this, session, streamId, (put) => {
 			if (keep) put(keep, { parentId: op.parentId });
-			_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, {
+			_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).settle(session, operationId, {
 				status: "unanswered",
-				reason: "aborted",
-				streamId: null
-			});
+				reason: "aborted"
+			}, { streamId: null });
 		});
 		await _assertClassBrand(_ThinkHarness_brand, this, _settled).call(this, session, operationId, keep);
 		return {};
@@ -1387,11 +1581,10 @@ async function _callModel(op, existing, tools, live) {
 		if (kind === "retry") return _assertClassBrand(_ThinkHarness_brand, this, _interrupted).call(this, op, streamId, keep);
 		await _assertClassBrand(_ThinkHarness_brand, this, _commit).call(this, session, streamId, (put) => {
 			if (keep) put(keep, { parentId: op.parentId });
-			_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, {
+			_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).settle(session, operationId, {
 				status: "unanswered",
-				reason: errorText(failure),
-				streamId: null
-			});
+				reason: errorText(failure)
+			}, { streamId: null });
 		});
 		await _assertClassBrand(_ThinkHarness_brand, this, _settled).call(this, session, operationId, keep);
 		return {};
@@ -1449,14 +1642,15 @@ async function _interrupted(op, streamId, partial) {
 	});
 	await _assertClassBrand(_ThinkHarness_brand, this, _commit).call(this, session, streamId, (put) => {
 		if (partial) put(partial, { parentId: op.parentId });
-		_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, {
+		const progress = {
 			streamId: null,
-			interruptions: attempt,
-			...decision === "abandon" && {
-				status: "unanswered",
-				reason: "interrupted"
-			}
-		});
+			interruptions: attempt
+		};
+		if (decision === "abandon") _assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).settle(session, operationId, {
+			status: "unanswered",
+			reason: "interrupted"
+		}, progress);
+		else _assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, progress);
 	});
 	if (partial) _classPrivateFieldGet2(_events, this).emit(session, {
 		type: "message",
@@ -1629,11 +1823,10 @@ async function _abandon(op, reason) {
 	const keep = message && hasContent(message) && message !== existing ? message : void 0;
 	await _assertClassBrand(_ThinkHarness_brand, this, _commit).call(this, session, op.streamId, (put) => {
 		if (keep) put(keep, { parentId: op.parentId });
-		_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).update(session, operationId, {
+		_assertClassBrand(_ThinkHarness_brand, this, _tables).call(this).settle(session, operationId, {
 			status: "unanswered",
-			reason,
-			streamId: null
-		});
+			reason
+		}, { streamId: null });
 	});
 	if (keep) _classPrivateFieldGet2(_events, this).emit(session, {
 		type: "message",
@@ -1687,8 +1880,7 @@ function _result(op) {
 	};
 }
 function _tables() {
-	_classPrivateFieldGet2(_records, this) ?? _classPrivateFieldSet2(_records, this, new OperationRecords(this.lifecycle.storage.sql));
-	_classPrivateFieldGet2(_records, this).ensureTables();
+	_classPrivateFieldGet2(_records, this) ?? _classPrivateFieldSet2(_records, this, new OperationRecords(this.lifecycle.storage));
 	return _classPrivateFieldGet2(_records, this);
 }
 /** The Sessions handle for a session, configured on first use. */