@inflexa-ai/harness 0.41.1 → 0.42.0

package/dist/memory/conversation-display-recorder.js

@@ -1,33 +1,36 @@
 import { randomUUID } from "node:crypto";
+import { applyChatFrame, checkChatPart, isRootFrame, toChatFrame } from "../contracts/chat-frame.js";
 import { PART_REGISTRY } from "../contracts/part-registry.js";
-import { CortexChatPartSchema } from "../contracts/schemas/chat-parts.js";
 import { compactionExchangeOf, compactionMarkerOf } from "./ai-sdk-message-storage.js";
 import { conversationDisplayPart } from "./conversation-display-storage.js";
 function jsonCopy(value) {
     return JSON.parse(JSON.stringify(value));
 }
-function isSubAgent(event, topLevelCallPath) {
-    if (!("source" in event) || event.source === undefined)
-        return false;
-    const path = event.source.callPath;
-    return path.length > topLevelCallPath.length && topLevelCallPath.every((entry, index) => path[index] === entry);
-}
 function durableConversationType(type) {
     if (!Object.hasOwn(PART_REGISTRY, type))
         return false;
     const descriptor = PART_REGISTRY[type];
     return descriptor.emitter === "conversation" && descriptor.consumer === "conversation" && !descriptor.transient;
 }
-function dataPart(event) {
-    const parsed = CortexChatPartSchema.safeParse({ type: event.type, ...event.data });
-    if (!parsed.success)
-        throw new Error(`Invalid emitted conversation part ${event.type}: ${parsed.error.message}`);
-    const { type, ...data } = parsed.data;
-    return {
-        type,
-        id: "id" in data && typeof data.id === "string" ? data.id : undefined,
-        data: jsonCopy(data),
-    };
+/** The checked part of a data frame, copied at receipt, because the emitter keeps its own reference to the payload. */
+function recordedPart(frame) {
+    const checked = checkChatPart(frame);
+    if (!checked.ok)
+        throw new Error(`Invalid emitted conversation part ${frame.type}: ${checked.error}`);
+    return jsonCopy(checked.frame);
+}
+/**
+ * The stored form of the parts of one round. A round that closes ends each question that it asked, thus a
+ * pending ask is stored `aborted`, and a call with no outcome is stored `incomplete` ({@link conversationDisplayPart}).
+ */
+function displayParts(parts) {
+    return parts.flatMap((part) => {
+        if (part.type === "text")
+            return part.text.length === 0 ? [] : [{ type: "text", text: part.text, state: "done" }];
+        if (part.type === "data-ask" && part.status === "pending")
+            return [conversationDisplayPart({ ...part, status: "aborted" })];
+        return [conversationDisplayPart(part)];
+    });
 }
 /** The text of the assistant messages of a round. The text of an exchange is a summary, and no reply. */
 function assistantText(messages) {
@@ -48,148 +51,85 @@ function compactionDivider(marker) {
         id: marker.id,
         status: marker.kind === "summary" ? "done" : "failed",
         tokensBefore: marker.tokensBefore,
-        tokensAfter: marker.tokensAfter,
         durationMs: marker.durationMs,
+        ...(marker.trigger === undefined ? {} : { trigger: marker.trigger }),
     });
     return { id: marker.id, role: "system", parts: [part] };
 }
+/**
+ * Record the display of a turn through the same translation path as a live surface: each event becomes a
+ * frame (`toChatFrame`), and the frames build the messages of the round (`applyChatFrame`). Only a part that
+ * the conversation keeps enters the record.
+ */
 export function createConversationDisplayRecorder(options) {
     // One id for each message of the turn, thus the rounds of a turn replay as one assistant message.
     const userMessageId = options.userMessageId ?? randomUUID();
     let assistantMessageId = options.assistantMessageId ?? randomUUID();
-    const assistantParts = [];
-    // Where a reconciling part lives, keyed by `type:id`. Type-qualified because a
-    // stable id is only unique within its own family — a plan and a run card may
-    // legitimately share one.
-    const reconcileIndexes = new Map();
+    const rootSource = { agentId: options.agentId, callPath: [options.agentId] };
+    // The messages of the open round. A later update of a part lands in the next round, and the replay replaces the earlier copy.
+    let round = [];
     let finished = false;
-    /**
-     * Place a part, replacing the one it reconciles with when it has a stable id.
-     * A tool call reaching its `finished` state and an `ask` reaching its resolved
-     * status are the same operation: latest-wins, in the position the part first
-     * took, so a later part never jumps the ordering the user saw.
-     */
-    function upsert(part, reconciling) {
-        if (!reconciling || part.id === undefined) {
-            assistantParts.push(part);
-            return;
-        }
-        const key = `${part.type}:${part.id}`;
-        const index = reconcileIndexes.get(key);
-        if (index !== undefined) {
-            assistantParts[index] = part;
-            return;
-        }
-        reconcileIndexes.set(key, assistantParts.length);
-        assistantParts.push(part);
+    function apply(frame) {
+        round = applyChatFrame(round, frame, assistantMessageId).messages;
+    }
+    function roundParts() {
+        return round.find((message) => message.id === assistantMessageId)?.parts ?? [];
     }
-    /**
-     * Place or update a call's recorded state.
-     *
-     * A call is recorded `incomplete` the moment it is dispatched and overwritten with
-     * its real outcome when it finishes. The record is therefore honest at every
-     * instant, and a turn that ends mid-call needs no closing pass — the calls that
-     * never finished are already saying so.
-     */
-    function recordToolCall(toolCallId, toolName, outcome, detail) {
-        upsert(conversationDisplayPart({
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            outcome,
-            ...(detail === undefined ? {} : { detail }),
-        }), true);
+    function hasText() {
+        return roundParts().some((part) => part.type === "text" && part.text.length > 0);
     }
     function appendText(text) {
-        if (text.length === 0)
+        if (text.length > 0)
+            apply({ type: "text-delta", text, source: rootSource });
+    }
+    function record(event) {
+        const frame = toChatFrame(event, rootSource);
+        if (frame === null || !isRootFrame(frame))
             return;
-        const previous = assistantParts.at(-1);
-        if (previous?.type === "text") {
-            previous.text += text;
+        if (frame.type.startsWith("data-")) {
+            // Each chat event type is named without the `data-` prefix, thus a `data-` frame is a part frame.
+            if (durableConversationType(frame.type))
+                apply(recordedPart(frame));
             return;
         }
-        assistantParts.push({ type: "text", text, state: "streaming" });
-    }
-    function recordData(event) {
-        if (!durableConversationType(event.type))
-            return;
-        upsert(dataPart(event), PART_REGISTRY[event.type].reconciling);
+        apply(frame);
     }
     const emit = (event) => {
-        if (finished)
-            return options.sink(event);
-        if (!isSubAgent(event, options.topLevelCallPath)) {
-            switch (event.type) {
-                case "text-delta":
-                    appendText(event.text);
-                    break;
-                // The detail the loop computed at dispatch is recorded as shown. It is
-                // NOT re-derived on reload: doing that would need the tool's schema and
-                // the raw input, which is the tool-name coupling the display projection
-                // exists to remove.
-                case "tool-started":
-                    recordToolCall(event.toolUseId, event.name, "incomplete", event.detail);
-                    break;
-                case "tool-finished":
-                    recordToolCall(event.toolUseId, event.name, event.outcome, event.detail);
-                    break;
-                case "done":
-                case "iteration":
-                    break;
-                default:
-                    recordData(event);
-                    break;
-            }
-        }
+        if (!finished)
+            record(event);
         return options.sink(event);
     };
-    function closeParts() {
-        // Calls need no closing pass: one that never reached `tool-finished` still holds
-        // the `incomplete` it was recorded with at dispatch, which is the whole of what
-        // the harness observed. An approval does need one — `pending` is a question, and
-        // a turn that ends without answering it aborted it.
-        for (const part of assistantParts) {
-            if (part.type === "data-ask" && part.data.status === "pending")
-                part.data.status = "aborted";
-            if (part.type === "text")
-                part.state = "done";
-        }
-    }
     function takeOpening() {
         return [{ id: userMessageId, role: "user", parts: [{ type: "text", text: options.userText, state: "done" }] }];
     }
     function takeRound(messages) {
-        if (!assistantParts.some((part) => part.type === "text"))
+        if (!hasText())
             appendText(assistantText(messages));
-        // Only a round that a throw ends can hold a pending approval.
-        closeParts();
-        const round = assistantParts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(assistantParts) }];
-        // A later update of a part lands in the next round, and the replay replaces the earlier copy.
-        assistantParts.length = 0;
-        reconcileIndexes.clear();
+        const parts = displayParts(roundParts());
+        const taken = parts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(parts) }];
+        round = [];
         const marker = messages.map(compactionMarkerOf).find((found) => found !== undefined);
         if (marker !== undefined) {
-            round.push(compactionDivider(marker));
+            taken.push(compactionDivider(marker));
             // The divider splits the turn into two assistant messages of the replay, and two messages must not share an id.
             assistantMessageId = randomUUID();
         }
-        return round;
+        return taken;
     }
     function finish(finishOptions) {
         if (!finished) {
             finished = true;
-            if (!assistantParts.some((part) => part.type === "text") && finishOptions?.fallbackText) {
+            if (!hasText() && finishOptions?.fallbackText)
                 appendText(finishOptions.fallbackText);
-            }
-            closeParts();
         }
         const messages = takeOpening();
-        if (assistantParts.length > 0) {
+        const parts = displayParts(roundParts());
+        if (parts.length > 0) {
             messages.push({
                 id: assistantMessageId,
                 role: "assistant",
                 ...(finishOptions?.interrupted ? { metadata: { interrupted: true } } : {}),
-                parts: jsonCopy(assistantParts),
+                parts: jsonCopy(parts),
             });
         }
         return messages;

package/dist/memory/conversation-display-replay.d.ts

@@ -1,11 +1,11 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * The runtime transcript read: stored display projections → `ChatMessage[]`. It walks the rows in
  * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
  * that message. It consults no tool name, no card builder, and no workspace or database.
  *
  * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
  * model transcript would let each later change of a tool or a card rewrite history.
  */
-import type { CortexMessage } from "../contracts/message.js";
+import type { ChatMessage } from "../contracts/message.js";
 import type { StoredMessage } from "./thread-history.js";
-export declare function storedMessagesToCortex(messages: readonly StoredMessage[]): CortexMessage[];
+export declare function storedMessagesToChat(messages: readonly StoredMessage[]): ChatMessage[];

package/dist/memory/conversation-display-replay.js

@@ -1,32 +1,18 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * The runtime transcript read: stored display projections → `ChatMessage[]`. It walks the rows in
  * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
  * that message. It consults no tool name, no card builder, and no workspace or database.
  *
  * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
  * model transcript would let each later change of a tool or a card rewrite history.
  */
-import { isReconciling } from "../contracts/part-registry.js";
+import { upsertPart } from "../contracts/chat-frame.js";
 import { isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
-import { conversationUIToCortexMessages } from "./conversation-display-storage.js";
-/** The key that a part reconciles on, or `undefined` for a part that each round adds again. */
-function reconcileKey(part) {
-    if (part.type === "tool-call")
-        return `tool-call:${part.toolCallId}`;
-    if (part.type === "text" || !isReconciling(part.type))
-        return undefined;
-    return "id" in part && typeof part.id === "string" ? `${part.type}:${part.id}` : undefined;
-}
+import { conversationUIToChatMessages } from "./conversation-display-storage.js";
 /** Add the parts of a later round to the assistant message of its turn. */
 function mergeRound(target, round) {
-    for (const part of round.parts) {
-        const key = reconcileKey(part);
-        const earlier = key === undefined ? -1 : target.parts.findIndex((candidate) => reconcileKey(candidate) === key);
-        if (earlier >= 0)
-            target.parts[earlier] = part;
-        else
-            target.parts.push(part);
-    }
+    for (const part of round.parts)
+        target.parts = upsertPart(target.parts, part);
 }
 function foldTurnRecord(message, record) {
     if (message === undefined || record === undefined)
@@ -38,7 +24,7 @@ function foldTurnRecord(message, record) {
     if (record.status === "aborted")
         message.interrupted = true;
 }
-export function storedMessagesToCortex(messages) {
+export function storedMessagesToChat(messages) {
     const out = [];
     // The last message of the group being walked, as `out` holds it.
     let groupLast;
@@ -62,7 +48,7 @@ export function storedMessagesToCortex(messages) {
             const createdAt = row.createdAt === undefined ? {} : { createdAt: row.createdAt.toISOString() };
             const author = row.author === undefined ? {} : { author: row.author };
             groupLast = undefined;
-            for (const message of conversationUIToCortexMessages(row.displayEnvelope.messages)) {
+            for (const message of conversationUIToChatMessages(row.displayEnvelope.messages)) {
                 const stamped = { ...message, ...createdAt, ...(message.role === "user" ? author : {}) };
                 const previous = out.at(-1);
                 // The merged message keeps the creation time of its first round.

package/dist/memory/conversation-display-storage.d.ts

@@ -4,20 +4,20 @@
  *
  * AI SDK `UIMessage` is the CONTAINER: it supplies message identity, role,
  * ordering, metadata, and `validateUIMessages` for runtime validation. The PARTS
- * vocabulary is Cortex's own, because ours is the richer one — a `CortexPart`
+ * vocabulary is the harness's own, because ours is the richer one — a `MessagePart`
  * carries a tool call's four-way outcome and its one-line detail, and AI SDK's
  * `dynamic-tool` part has nowhere to put either. Mapping through `dynamic-tool`
  * would silently drop both on every reload, so every non-text part rides as a
- * typed `DataUIPart` whose payload IS the Cortex part minus its discriminant.
+ * typed `DataUIPart` whose payload IS the message part minus its discriminant.
  *
  * The projection is therefore lossless in both directions, and the read path
- * ({@link conversationUIToCortexMessages}) is a near-identity rather than a
+ * ({@link conversationUIToChatMessages}) is a near-identity rather than a
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
 import type { AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
-import type { CortexMessage, CortexPart, ToolCallPart } from "../contracts/message.js";
+import type { ChatMessage, MessagePart, ToolCallPart } from "../contracts/message.js";
 import type { Logger } from "../lib/logger.js";
 export declare const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 type Payload<T extends {
@@ -26,7 +26,7 @@ type Payload<T extends {
 /**
  * The AI SDK custom-data vocabulary persisted for one conversation display.
  *
- * Each key `k` becomes a `data-${k}` part whose payload is the matching Cortex
+ * Each key `k` becomes a `data-${k}` part whose payload is the matching message
  * part without its `type` field, so a stored part and a wire part differ only in
  * where the discriminant lives.
  */
@@ -56,24 +56,24 @@ export interface StoredDisplayEnvelope {
 export declare function envelopeDisplayMessages(messages: readonly ConversationUIMessage[]): StoredDisplayEnvelope;
 export declare function parseStoredDisplayEnvelope(value: unknown, identity: string, logger?: Logger): Promise<StoredDisplayEnvelope>;
 /**
- * Build the stored form of one non-text Cortex part.
+ * Build the stored form of one non-text message part.
  *
- * A tool call is the one part whose stored payload is not simply the Cortex part
+ * A tool call is the one part whose stored payload is not simply the message part
  * minus its discriminant: `outcome` is optional on the live part (absent means in
  * flight) and required here, because a record is of a call that is no longer
  * running. An in-flight call being recorded is one the turn never saw finish, so
  * absence resolves to `incomplete` at exactly this boundary — once, where the
  * lifetime changes — rather than at each reader.
  */
-export declare function conversationDisplayPart(part: Exclude<CortexPart, {
+export declare function conversationDisplayPart(part: Exclude<MessagePart, {
     type: "text";
 }>): DataUIPart<ConversationUIData>;
 /**
- * Read the durable representation back as Cortex display messages.
+ * Read the durable representation back as chat messages.
  *
  * Every part round-trips by moving its discriminant back out of the part type,
  * so nothing here consults a tool name, a registry, or the filesystem. A message
  * whose parts all render empty is dropped so the transcript has no empty bubbles.
  */
-export declare function conversationUIToCortexMessages(messages: readonly ConversationUIMessage[]): CortexMessage[];
+export declare function conversationUIToChatMessages(messages: readonly ConversationUIMessage[]): ChatMessage[];
 export {};

package/dist/memory/conversation-display-storage.js

@@ -4,14 +4,14 @@
  *
  * AI SDK `UIMessage` is the CONTAINER: it supplies message identity, role,
  * ordering, metadata, and `validateUIMessages` for runtime validation. The PARTS
- * vocabulary is Cortex's own, because ours is the richer one — a `CortexPart`
+ * vocabulary is the harness's own, because ours is the richer one — a `MessagePart`
  * carries a tool call's four-way outcome and its one-line detail, and AI SDK's
  * `dynamic-tool` part has nowhere to put either. Mapping through `dynamic-tool`
  * would silently drop both on every reload, so every non-text part rides as a
- * typed `DataUIPart` whose payload IS the Cortex part minus its discriminant.
+ * typed `DataUIPart` whose payload IS the message part minus its discriminant.
  *
  * The projection is therefore lossless in both directions, and the read path
- * ({@link conversationUIToCortexMessages}) is a near-identity rather than a
+ * ({@link conversationUIToChatMessages}) is a near-identity rather than a
  * reconstruction.
  */
 import { validateUIMessages } from "ai";
@@ -44,6 +44,7 @@ const ToolCallDisplaySchema = z.object({
     toolName: z.string(),
     outcome: ToolCallOutcomeSchema,
     detail: z.string().optional(),
+    durationMs: z.number().optional(),
 });
 /**
  * The schema behind each stored part key.
@@ -152,7 +153,7 @@ export async function parseStoredDisplayEnvelope(value, identity, logger) {
         throw new Error(`Invalid stored conversation display envelope at ${identity}: ${message}`, { cause: error });
     }
 }
-/** The data-part key a Cortex part is stored under — its `type` minus the `data-` prefix. */
+/** The data-part key a message part is stored under — its `type` minus the `data-` prefix. */
 function displayPartType(part) {
     return (part.type === "tool-call" ? "data-tool-call" : part.type);
 }
@@ -163,9 +164,9 @@ function displayPartId(part) {
     return "id" in part && typeof part.id === "string" ? part.id : undefined;
 }
 /**
- * Build the stored form of one non-text Cortex part.
+ * Build the stored form of one non-text message part.
  *
- * A tool call is the one part whose stored payload is not simply the Cortex part
+ * A tool call is the one part whose stored payload is not simply the message part
  * minus its discriminant: `outcome` is optional on the live part (absent means in
  * flight) and required here, because a record is of a call that is no longer
  * running. An in-flight call being recorded is one the turn never saw finish, so
@@ -178,13 +179,13 @@ export function conversationDisplayPart(part) {
     return { type: displayPartType(part), id: displayPartId(part), data };
 }
 /**
- * Read the durable representation back as Cortex display messages.
+ * Read the durable representation back as chat messages.
  *
  * Every part round-trips by moving its discriminant back out of the part type,
  * so nothing here consults a tool name, a registry, or the filesystem. A message
  * whose parts all render empty is dropped so the transcript has no empty bubbles.
  */
-export function conversationUIToCortexMessages(messages) {
+export function conversationUIToChatMessages(messages) {
     const out = [];
     for (const message of messages) {
         const parts = [];

package/dist/memory/conversation-view.d.ts

@@ -47,7 +47,8 @@ export interface ConversationView {
 export declare function conversationView(messages: readonly ModelMessage[], options: ConversationViewOptions): ConversationView;
 /** The message with no reasoning part, or `undefined` for an assistant message with no part left. */
 export declare function withoutReasoning(message: ModelMessage): ModelMessage | undefined;
-/** The estimate of the messages, by the count that the store writes to the `tokens` column. */
-export declare function viewTokens(messages: readonly ModelMessage[]): number;
-/** The count of the turns that a drop keeps: the newest turn, and each older turn while the view stays within `budget`. */
-export declare function keptTurnsForDrop(messages: readonly ModelMessage[], options: ConversationViewOptions, budget: number): number;
+/**
+ * The input tokens that the provider reported for the last request of the conversation. A marker changes the
+ * conversation, thus a request before the latest marker gives `undefined`.
+ */
+export declare function lastRequestInputTokens(messages: readonly ModelMessage[]): number | undefined;

package/dist/memory/conversation-view.js

@@ -4,8 +4,7 @@
  * turns of the body without their reasoning. The loop and the reader call this one function, thus the
  * next turn reads back the prefix that the last request sent.
  */
-import { compactionExchangeOf, compactionMarkerOf, isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
-import { countTokens } from "./count-tokens.js";
+import { compactionExchangeOf, compactionMarkerOf, isSyntheticUserMessage, requestInputTokensOf } from "./ai-sdk-message-storage.js";
 /**
  * A turn starts on a `user` message that a human actually sent. Two kinds of
  * message carry the `user` role without opening a turn, and both are excluded
@@ -110,21 +109,18 @@ export function withoutReasoning(message) {
         return message;
     return content.length === 0 ? undefined : { ...message, content };
 }
-/** The estimate of the messages, by the count that the store writes to the `tokens` column. */
-export function viewTokens(messages) {
-    return messages.reduce((sum, message) => sum + countTokens(message.content), 0);
-}
-/** The count of the turns that a drop keeps: the newest turn, and each older turn while the view stays within `budget`. */
-export function keptTurnsForDrop(messages, options, budget) {
-    const { head, front, body } = viewParts(messages, options);
-    const turnTokens = groupTurns(body, startsTurn).map((turn) => viewTokens(withoutReasoningEntries(turn).map((entry) => entry.message)));
-    let total = viewTokens([...head, ...(front === undefined ? [] : [front])].map((entry) => entry.message));
-    let kept = 0;
-    for (let t = turnTokens.length - 1; t >= 0; t--) {
-        if (kept > 0 && total + turnTokens[t] > budget)
-            break;
-        total += turnTokens[t];
-        kept++;
+/**
+ * The input tokens that the provider reported for the last request of the conversation. A marker changes the
+ * conversation, thus a request before the latest marker gives `undefined`.
+ */
+export function lastRequestInputTokens(messages) {
+    for (let at = messages.length - 1; at >= 0; at--) {
+        const message = messages[at];
+        if (compactionMarkerOf(message) !== undefined)
+            return undefined;
+        const tokens = requestInputTokensOf(message);
+        if (tokens !== undefined)
+            return tokens;
     }
-    return kept;
+    return undefined;
 }

package/dist/memory/count-tokens.js

@@ -63,6 +63,7 @@ function tokenizableText(block) {
         case "reasoning-file":
         case "custom":
         case "file":
+        case "image":
             return "";
         case "tool-call":
             return `${String(part.toolName ?? "")} ${JSON.stringify(part.input ?? {})}`;

package/dist/memory/message-backfill.d.ts

@@ -1,2 +1,8 @@
-import type { PoolClient } from "pg";
-export declare function backfillAiSdkMessageEnvelopes(client: PoolClient): Promise<void>;
+import type { QueryResultRow } from "pg";
+/** The query method of a `pg` client, which the migration transaction also supplies. */
+export interface BackfillClient {
+    query<R extends QueryResultRow>(text: string, values?: unknown[]): Promise<{
+        rows: R[];
+    }>;
+}
+export declare function backfillAiSdkMessageEnvelopes(client: BackfillClient): Promise<void>;

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

@@ -193,10 +193,17 @@ export interface ThreadStore {
     /** The live thread by id, or `null` if absent or archived. */
     getThread(threadId: string): ResultAsync<Thread | null, DbError>;
     /**
-     * Set only the title, bumping `updated_at` forward — never behind the stamp
-     * the row already carries. No-op on a missing/archived row.
+     * A rename by a person. Set the title and `title_set_by_user`, thus no
+     * automatic title replaces it. Bumps `updated_at` forward — never behind the
+     * stamp the row already carries. No-op on a missing/archived row.
      */
     updateTitle(threadId: string, title: string): ResultAsync<Thread | null, DbError>;
+    /**
+     * An automatic title. Set the title only while no person set one, with the
+     * same forward-only bump as `updateTitle`. `null` when the row is missing,
+     * archived, or titled by a person.
+     */
+    setAutoTitle(threadId: string, title: string): ResultAsync<Thread | null, DbError>;
     /**
      * Soft-delete the subtree: stamp `deleted_at` on the named thread and on
      * every descendant reachable through `parent_thread_id`, at any depth, so a

package/dist/memory/thread-store.js

@@ -220,10 +220,16 @@ export function createThreadStore(pool) {
         // give that: it reads this transaction's START time, not the moment the
         // row is actually written.
         `UPDATE cortex_analysis_threads
-         SET title = $2, updated_at = GREATEST(updated_at, clock_timestamp())
+         SET title = $2, title_set_by_user = true, updated_at = GREATEST(updated_at, clock_timestamp())
          WHERE thread_id = $1 AND deleted_at IS NULL
          RETURNING ${THREAD_COLUMNS}`, [threadId, title])).map(({ rows }) => (rows[0] ? toThread(rows[0]) : null));
     }
+    function setAutoTitle(threadId, title) {
+        return tryMutation("thread-store.setAutoTitle", () => pool.query(`UPDATE cortex_analysis_threads
+         SET title = $2, updated_at = GREATEST(updated_at, clock_timestamp())
+         WHERE thread_id = $1 AND deleted_at IS NULL AND NOT title_set_by_user
+         RETURNING ${THREAD_COLUMNS}`, [threadId, title])).map(({ rows }) => (rows[0] ? toThread(rows[0]) : null));
+    }
     function archiveThread(threadId) {
         return tryMutation("thread-store.archiveThread", () => pool.query(
         // The stamp reaches the whole subtree because a hidden thread must
@@ -360,5 +366,5 @@ export function createThreadStore(pool) {
             }));
         });
     }
-    return { createThread, getThread, updateTitle, archiveThread, unarchiveThread, purgeThread, listThreads };
+    return { createThread, getThread, updateTitle, setAutoTitle, archiveThread, unarchiveThread, purgeThread, listThreads };
 }

package/dist/prompts/compaction.d.ts

@@ -1,4 +1,4 @@
 /** The compaction request of a thread whose agent maintains the working memory. */
-export declare const MEMORY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary.\n\nFirst, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. Keep each constraint that the user gave as it is, because the user set it. No other tool can run now. Send all the memory edits in at most 3 replies, and put many calls in one reply. The reply after the edits must be the summary: if it calls a tool, the harness gets no summary.\n\nThen reply in plain text with the summary. Leave out each fact that a memory edit accepted. If the memory refused an edit, put that fact in the summary. Give:\n- the current request of the user in its exact words\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
+export declare const MEMORY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary.\n\nFirst, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. Keep each constraint that the user gave as it is, because the user set it. No other tool can run now. Send all the memory edits in at most 3 replies, and put many calls in one reply. The reply after the edits must be the summary: if it calls a tool, the harness gets no summary.\n\nThen reply in plain text with the summary. Leave out each fact that a memory edit accepted. If the memory refused an edit, put that fact in the summary. Give:\n- the last request of the user in its exact words\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
 /** The compaction request of a thread that reads a frozen copy of the working memory, for example a report thread. */
-export declare const SUMMARY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary. No tool can run now.\n\nReply in plain text with the summary. Leave out what the working memory holds. Give:\n- the goals, and the current request of the user in its exact words\n- each change that the user made to the brief\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
+export declare const SUMMARY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary. No tool can run now.\n\nReply in plain text with the summary. Leave out what the working memory holds. Give:\n- the goals, and the last request of the user in its exact words\n- each change that the user made to the brief\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";

package/dist/prompts/compaction.js

@@ -5,7 +5,7 @@ export const MEMORY_COMPACTION_REQUEST = `The conversation is too long for the c
 First, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. Keep each constraint that the user gave as it is, because the user set it. No other tool can run now. Send all the memory edits in at most ${COMPACTION_MAX_REQUESTS - 1} replies, and put many calls in one reply. The reply after the edits must be the summary: if it calls a tool, the harness gets no summary.
 
 Then reply in plain text with the summary. Leave out each fact that a memory edit accepted. If the memory refused an edit, put that fact in the summary. Give:
-- the current request of the user in its exact words
+- the last request of the user in its exact words
 - the decisions, with their reasons
 - the approaches that failed or that the user ruled out, with the reasons
 - the open questions
@@ -17,7 +17,7 @@ The conversation continues from your summary, the working memory, and the messag
 export const SUMMARY_COMPACTION_REQUEST = `The conversation is too long for the context window. The harness replaces the conversation above with your summary. No tool can run now.
 
 Reply in plain text with the summary. Leave out what the working memory holds. Give:
-- the goals, and the current request of the user in its exact words
+- the goals, and the last request of the user in its exact words
 - each change that the user made to the brief
 - the decisions, with their reasons
 - the approaches that failed or that the user ruled out, with the reasons