@inflexa-ai/harness 0.24.0 → 0.26.0

package/dist/memory/content-to-cortex.js

@@ -1,201 +0,0 @@
-/**
- * The MIGRATION renderer: stored AI SDK model messages → `CortexMessage[]`.
- *
- * This is how a conversation written before display projections were persisted
- * is rendered ONCE, at startup, so it can be frozen into a display envelope
- * (`conversation-display-backfill.ts`). It is not a runtime read path — the
- * runtime reads the stored projection (`conversation-display-replay.ts`) and
- * never consults a tool name, a card builder, or the filesystem.
- *
- * Everything it does is inference from a transcript that was never meant to
- * carry display, which is why it belongs to the migration and nothing else:
- *
- *   - text part         → text part
- *   - tool-call part    → a reconstructed display card (`data-plan`,
- *                         `data-presentation`) when `resolveCard` recognises
- *                         the tool, else a generic tool-call part whose detail
- *                         `resolveDetail` recomputes from the persisted input
- *   - everything else   → dropped (reasoning, tool-result, etc.) — the UI
- *                         does not render them
- *
- * A `tool-result` block is not rendered, but it is not ignored either: it is the
- * only record of how its call ended. The blocks are indexed by `toolCallId`
- * before conversion so each tool-call part can report its own outcome — without
- * that pass every migrated call would report success, including the failed ones.
- *
- * A row that yields no renderable parts (e.g. a `tool`-role message carrying
- * only tool-result continuation parts) is omitted entirely, so the rendered
- * conversation has no empty bubbles. Storage is never mutated.
- */
-import { toolOutcomeForOutputType } from "../loop/tool-outcome.js";
-import { isInterruptedMessage, isSyntheticRecordMessage, isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
-/**
- * How each stored call ended, keyed by tool-call id.
- *
- * A whole page is indexed before conversion because the pairing crosses rows: a
- * call rides an `assistant` row and its result rides the `tool` row after it.
- */
-function indexOutcomes(messages) {
-    const outcomes = new Map();
-    for (const { message } of messages) {
-        const content = message.content;
-        if (typeof content === "string")
-            continue;
-        for (const block of content) {
-            if (block.type !== "tool-result")
-                continue;
-            outcomes.set(block.toolCallId, toolOutcomeForOutputType(block.output.type));
-        }
-    }
-    return outcomes;
-}
-function genericToolCall(block, outcomes, resolveDetail) {
-    // No paired result is the shape of a transcript whose `tool` row was never
-    // appended — an aborted turn. That is not a success: the call was dispatched and
-    // never completed, which is exactly `incomplete`. Reporting `ok` would claim a
-    // result the tool never returned, and it is the one outcome the transcript
-    // genuinely cannot supply, so it is named rather than guessed at.
-    const outcome = outcomes.get(block.toolCallId) ?? "incomplete";
-    const detail = resolveDetail?.(block.toolName, block.input);
-    return {
-        type: "tool-call",
-        toolCallId: block.toolCallId,
-        toolName: block.toolName,
-        outcome,
-        ...(detail === undefined ? {} : { detail }),
-    };
-}
-async function blockToPart(block, outcomes, options) {
-    if (block.type === "text")
-        return { type: "text", text: block.text };
-    if (block.type === "tool-call") {
-        const card = options.resolveCard
-            ? await options.resolveCard({ type: "tool_use", id: block.toolCallId, name: block.toolName, input: block.input })
-            : null;
-        return card ?? genericToolCall(block, outcomes, options.resolveDetail);
-    }
-    // reasoning, tool_result, file, and any other block — not rendered.
-    return null;
-}
-async function rowToParts(message, outcomes, options) {
-    const content = message.content;
-    if (typeof content === "string") {
-        return content.length > 0 ? [{ type: "text", text: content }] : [];
-    }
-    const parts = [];
-    for (const block of content) {
-        const part = await blockToPart(block, outcomes, options);
-        if (part)
-            parts.push(part);
-    }
-    return parts;
-}
-/**
- * Map stored messages (oldest-first) to `CortexMessage[]`. Rows that produce
- * no renderable parts are dropped, and consecutive assistant rows are coalesced
- * into one message. The first row's `seq` becomes the stable message id.
- * `options.resolveCard` reconstructs display cards from `tool_use` blocks and
- * `options.resolveDetail` reconstructs each call's one-line detail; both are
- * optional and each tool-call part reports its outcome either way.
- * A row carrying the interruption marker sets `interrupted: true` on the message
- * it lands in, including when coalesced into an assistant run; a row carrying a
- * stored turn rollup sets `usage` the same way. A row that carries a stored turn
- * duration sets `durationMs` the same way too. Thus a reloaded conversation shows
- * the cost and the time that the live turn showed, with no second query.
- *
- * Coalescing mirrors the live SSE shape. The agent loop persists each assistant
- * step (typically a single `tool_use`) as its own row, and the `tool_result`
- * `user` rows between them drop to zero renderable parts above — so one assistant
- * turn is stored as a run of adjacent assistant rows. The live chat stream
- * accumulates that whole turn into a single assistant message whose `parts` hold
- * every step; reconstructing it row-by-row instead would emit one message per
- * tool call, which the UI renders as a stack of single-tool boxes. Merging the
- * run restores the one-bubble-per-turn shape (and lets the UI collapse the tool
- * calls into one group) regardless of how the loop split the turn into rows.
- *
- * Coalescing is assistant-only. User rows never legitimately split into a run —
- * adjacent `user` rows arise only from turns that persisted no reply (an aborted
- * turn's lone user message followed by the next turn's), and merging them would
- * fabricate one bubble from two messages the user sent separately.
- */
-export async function contentToCortexMessages(messages, options = {}) {
-    const outcomes = indexOutcomes(messages);
-    const out = [];
-    for (const message of messages) {
-        // The loop's truncation nudge carries the `user` role only for the wire
-        // format; rendering it would show words the user never typed, so drop it.
-        // Skipping first is safe: a synthetic user message can never carry the
-        // interruption marker — that rides assistant rows — so this cannot interact
-        // with the marker-fold logic below. The assistant rows it separated then
-        // become adjacent and coalesce into one bubble, which is the shape we want.
-        //
-        // A host-appended RECORD is the exception, and the distinction is exactly why the
-        // two markers exist separately: it is equally synthetic for every turn-boundary
-        // reader, but it is a fact the reader is entitled to see — the only trace in the
-        // conversation that out-of-band work happened at all. Dropping it here would make
-        // an embedder's durable record write successfully and then be invisible, with
-        // nothing to indicate why.
-        const isRecord = isSyntheticRecordMessage(message.message);
-        if (isSyntheticUserMessage(message.message) && !isRecord)
-            continue;
-        const parts = await rowToParts(message.message, outcomes, options);
-        // The marker is read before the zero-parts drop so the flag can never be lost to it:
-        // a marked row carries an interruption fact regardless of whether it renders any parts.
-        // When such a row contributes no bubble of its own, the interruption belongs to the
-        // assistant run it trailed, so fold the flag onto the previous emitted assistant.
-        const interrupted = isInterruptedMessage(message.message);
-        if (parts.length === 0) {
-            // The stored rollup of a row and its stored duration are facts about the turn,
-            // and not about what the row renders. Thus the read of both comes before the
-            // zero-parts drop, exactly as the read of the interruption marker does. The
-            // fold then puts them on the assistant run that they trailed. Without the fold,
-            // a turn whose last assistant row held unrendered blocks alone would lose the
-            // two figures to the drop. That loss is the one that the stored figures end.
-            const prev = out[out.length - 1];
-            if (prev && prev.role === "assistant") {
-                if (interrupted)
-                    prev.interrupted = true;
-                if (message.usage)
-                    prev.usage = message.usage;
-                if (message.durationMs !== undefined)
-                    prev.durationMs = message.durationMs;
-            }
-            continue;
-        }
-        // A record carries the `user` role for the wire format and for the turn-boundary
-        // predicates, but nobody said it. Emitting it AS `user` would attribute
-        // system-authored text to the reader — a lie about who spoke, and one that would
-        // also mislead them about what they can retract. `system` is what it actually is.
-        const role = isRecord
-            ? "system"
-            : message.message.role === "tool"
-                ? "assistant"
-                : message.message.role;
-        const prev = out[out.length - 1];
-        if (prev && prev.role === role && role === "assistant") {
-            prev.parts.push(...parts);
-            if (interrupted)
-                prev.interrupted = true;
-            // Coalescing rebuilds the one-bubble-per-turn shape, and the two figures ride
-            // the LAST assistant row of the turn. Thus the run keeps the figures of
-            // whichever row carried them. An assignment, and not a merge, is deliberate:
-            // two rollups in one run would mean that coalescing merged two turns, and it
-            // never does. The duration reads against `undefined`, because a measured zero
-            // is a figure and an absent value alone means that nobody measured the turn.
-            if (message.usage)
-                prev.usage = message.usage;
-            if (message.durationMs !== undefined)
-                prev.durationMs = message.durationMs;
-            continue;
-        }
-        const cortex = { id: String(message.seq), role, parts };
-        if (interrupted)
-            cortex.interrupted = true;
-        if (message.usage)
-            cortex.usage = message.usage;
-        if (message.durationMs !== undefined)
-            cortex.durationMs = message.durationMs;
-        out.push(cortex);
-    }
-    return out;
-}

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

@@ -1,23 +0,0 @@
-import type { Pool } from "pg";
-import type { Tool } from "../tools/define-tool.js";
-export interface ConversationDisplayBackfillDeps {
-    readonly pool: Pool;
-    /**
-     * The conversation agent's composed roster, used to recover each legacy call's
-     * one-line detail from its persisted input. Tools contributed through the
-     * host-tools seam are invisible to any map the harness holds on its own, so the
-     * list has to come from the assembled runtime.
-     */
-    readonly tools: readonly Tool[];
-    readonly batchSize?: number;
-}
-/**
- * Freeze the migration renderer's output into display envelopes, once per legacy
- * turn, so the runtime read path never has to reconstruct anything.
- *
- * Missing mutable resources degrade to a generic, cardless display — a plan
- * that is absent is normal historical absence, not a fault. Malformed stored rows
- * and database faults remain startup-fatal: a turn that cannot be migrated must
- * not be silently skipped and then read as if it had no display.
- */
-export declare function backfillConversationDisplayEnvelopes(deps: ConversationDisplayBackfillDeps): Promise<number>;

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

@@ -1,91 +0,0 @@
-import { createDetailResolver } from "../tools/detail-resolver.js";
-import { envelopeDisplayMessages, cortexMessagesToConversationUI, parseStoredDisplayEnvelope } from "./conversation-display-storage.js";
-import { parseStoredMessageEnvelope } from "./ai-sdk-message-storage.js";
-import { contentToCortexMessages } from "./content-to-cortex.js";
-import { createCardResolver } from "./reconstruct-cards.js";
-const BATCH_SIZE = 100;
-const GENUINE_USER_SQL = `m.message_envelope->'message'->>'role' = 'user'
-  AND m.message_envelope->'message'->'providerOptions'->'cortex'->>'synthetic' IS DISTINCT FROM 'true'`;
-/**
- * Freeze the migration renderer's output into display envelopes, once per legacy
- * turn, so the runtime read path never has to reconstruct anything.
- *
- * Missing mutable resources degrade to a generic, cardless display — a plan
- * that is absent is normal historical absence, not a fault. Malformed stored rows
- * and database faults remain startup-fatal: a turn that cannot be migrated must
- * not be silently skipped and then read as if it had no display.
- */
-export async function backfillConversationDisplayEnvelopes(deps) {
-    const batchSize = Math.max(1, deps.batchSize ?? BATCH_SIZE);
-    const resolveDetail = createDetailResolver(deps.tools);
-    let migrated = 0;
-    let validationOffset = 0;
-    for (;;) {
-        const { rows } = await deps.pool.query(`SELECT thread_id, seq::text AS seq, display_envelope
-               FROM messages
-              WHERE display_envelope IS NOT NULL
-              ORDER BY thread_id, seq
-              LIMIT $1 OFFSET $2`, [batchSize, validationOffset]);
-        await Promise.all(rows.map((row) => parseStoredDisplayEnvelope(row.display_envelope, `${row.thread_id}/${row.seq}/display`)));
-        if (rows.length < batchSize)
-            break;
-        validationOffset += rows.length;
-    }
-    for (;;) {
-        const { rows: heads } = await deps.pool.query(`SELECT m.thread_id, m.seq::text AS seq, t.analysis_id
-               FROM messages m
-               LEFT JOIN cortex_analysis_threads t ON t.thread_id = m.thread_id
-              WHERE ${GENUINE_USER_SQL}
-                AND m.display_envelope IS NULL
-              ORDER BY m.thread_id, m.seq
-              LIMIT $1`, [batchSize]);
-        if (heads.length === 0)
-            return migrated;
-        for (const head of heads) {
-            const { rows } = await deps.pool.query(`SELECT m.seq::text AS seq, m.message_envelope
-                   FROM messages m
-                  WHERE m.thread_id = $1
-                    AND m.seq >= $2::bigint
-                    AND m.seq < COALESCE(
-                      (
-                        SELECT MIN(next.seq)
-                          FROM messages next
-                         WHERE next.thread_id = m.thread_id
-                           AND next.seq > $2::bigint
-                           AND next.message_envelope->'message'->>'role' = 'user'
-                           AND next.message_envelope->'message'->'providerOptions'->'cortex'->>'synthetic' IS DISTINCT FROM 'true'
-                      ),
-                      9223372036854775807
-                    )
-                  ORDER BY m.seq`, [head.thread_id, head.seq]);
-            const stored = rows.map((row) => {
-                const envelope = parseStoredMessageEnvelope(row.message_envelope, `${head.thread_id}/${row.seq}`);
-                return { seq: Number(row.seq), envelope, message: envelope.message };
-            });
-            let resolveCard;
-            if (head.analysis_id !== null) {
-                resolveCard = createCardResolver(deps.pool, head.analysis_id);
-            }
-            const cortex = await contentToCortexMessages(stored, { resolveCard, resolveDetail });
-            const uiMessages = cortexMessagesToConversationUI(cortex);
-            // A genuine turn always contributes at least its user message. Keep a
-            // defensive model-derived fallback so absence can never strand a NULL
-            // envelope and make startup retry forever.
-            const display = uiMessages.length > 0
-                ? uiMessages
-                : [
-                    {
-                        id: head.seq,
-                        role: "user",
-                        parts: [{ type: "text", text: "", state: "done" }],
-                    },
-                ];
-            const envelope = envelopeDisplayMessages(display);
-            const result = await deps.pool.query(`UPDATE messages
-                    SET display_envelope = $1::jsonb
-                  WHERE thread_id = $2 AND seq = $3::bigint
-                    AND display_envelope IS NULL`, [JSON.stringify(envelope), head.thread_id, head.seq]);
-            migrated += result.rowCount ?? 0;
-        }
-    }
-}

package/dist/memory/reconstruct-cards.d.ts

@@ -1,27 +0,0 @@
-/**
- * @deprecated Compatibility-only reconstruction for pre-display-envelope
- * turns. New runtime reads use stored AI SDK UI messages. Retain this module
- * through the pre-v1 direct-upgrade window, then remove its runtime fallback
- * in a dedicated compatibility change.
- *
- * `show_plan` / `show_user` / `show_file` / `execute_analysis` emit
- * `data-plan` / `data-presentation` / `data-file-reference` / `data-run-card` cards
- * live over the chat SSE stream. On reload, `content-to-cortex` calls this
- * resolver for each AI SDK tool-call part: a recognised display tool yields its card (rebuilt via the
- * shared `card-builders`); anything else yields `null` and falls back to a
- * generic `tool-call` chip. Keyed by the analysis `Pool` + id (plan / run) so
- * the card can be re-loaded.
- */
-import type { CortexPart } from "@inflexa-ai/harness/contracts/message.js";
-import type { Pool } from "pg";
-/** @deprecated Used only by the legacy display backfill/fallback. */
-export interface StoredToolCallForCard {
-    readonly type: "tool_use";
-    readonly id: string;
-    readonly name: string;
-    readonly input: unknown;
-}
-/** @deprecated Used only by the legacy display backfill/fallback. */
-export type ToolCardResolver = (block: StoredToolCallForCard) => Promise<CortexPart | null>;
-/** @deprecated Use persisted conversation display envelopes for runtime reads. */
-export declare function createCardResolver(pool: Pool, analysisId: string): ToolCardResolver;

package/dist/memory/reconstruct-cards.js

@@ -1,57 +0,0 @@
-/**
- * @deprecated Compatibility-only reconstruction for pre-display-envelope
- * turns. New runtime reads use stored AI SDK UI messages. Retain this module
- * through the pre-v1 direct-upgrade window, then remove its runtime fallback
- * in a dedicated compatibility change.
- *
- * `show_plan` / `show_user` / `show_file` / `execute_analysis` emit
- * `data-plan` / `data-presentation` / `data-file-reference` / `data-run-card` cards
- * live over the chat SSE stream. On reload, `content-to-cortex` calls this
- * resolver for each AI SDK tool-call part: a recognised display tool yields its card (rebuilt via the
- * shared `card-builders`); anything else yields `null` and falls back to a
- * generic `tool-call` chip. Keyed by the analysis `Pool` + id (plan / run) so
- * the card can be re-loaded.
- */
-import { unwrapOrThrow } from "../lib/result.js";
-import { adHocPlanId, adHocRunId } from "../tools/analysis-invocation.js";
-import { validatePath } from "../tools/lib/path-validation.js";
-import { buildFileReferenceCardData, buildPlanCardData, buildPresentationCardData, buildRunCardData } from "./card-builders.js";
-/** @deprecated Use persisted conversation display envelopes for runtime reads. */
-export function createCardResolver(pool, analysisId) {
-    return async (block) => {
-        if (block.type !== "tool_use")
-            return null;
-        const input = (block.input ?? {});
-        if (block.name === "show_user") {
-            // The live tool rejects a malformed/traversal echart `dataPath` and emits nothing; the
-            // persisted tool_use still carries it, so the reload path MUST re-validate before building
-            // the card — otherwise an unvalidated path is resurrected for the host to join into the
-            // workspace root. Invalid → no card (chip fallback), matching the live "emitted nothing".
-            if (typeof input.dataPath === "string" && validatePath(input.dataPath) !== null)
-                return null;
-            const card = buildPresentationCardData(input);
-            return card ? { type: "data-presentation", ...card } : null;
-        }
-        if (block.name === "show_file") {
-            const card = buildFileReferenceCardData(input);
-            return card ? { type: "data-file-reference", ...card } : null;
-        }
-        if (block.name === "show_plan") {
-            const planId = typeof input.planId === "string" ? input.planId : null;
-            if (!planId)
-                return null;
-            const title = typeof input.title === "string" ? input.title : undefined;
-            const card = unwrapOrThrow(await buildPlanCardData(pool, planId, analysisId, title));
-            return card ? { type: "data-plan", ...card } : null;
-        }
-        if (block.name === "execute_analysis" && (input.mode === "plan" || input.mode === "adhoc")) {
-            const planId = input.mode === "plan" ? (typeof input.planId === "string" ? input.planId : null) : adHocPlanId(analysisId, block.id);
-            if (planId === null)
-                return null;
-            const runId = input.mode === "adhoc" ? adHocRunId(analysisId, block.id) : undefined;
-            const card = unwrapOrThrow(await buildRunCardData(pool, { planId, analysisId, ...(runId !== undefined ? { runId } : {}) }));
-            return card ? { type: "data-run-card", ...card } : null;
-        }
-        return null;
-    };
-}