@inflexa-ai/harness 0.22.1 → 0.24.0

package/dist/loop/run-agent.d.ts

@@ -8,6 +8,11 @@ import { type AgentRunUsage } from "./metrics.js";
 import type { AgentDefinition, EmitFn, LoopMessage, RunStep } from "./types.js";
 export interface AgentFinish {
     readonly reason: FinishReason | "aborted" | "max_iterations" | "denied";
+    /**
+     * The endpoint's own word for the stop, when the provider captured one —
+     * `reason` normalizes it (an Anthropic `refusal` becomes `content-filter`).
+     */
+    readonly rawFinishReason?: string;
     readonly cappedOut: boolean;
     readonly truncationRecoveries: number;
     /**

package/dist/loop/run-agent.js

@@ -5,6 +5,7 @@ import { stripNulCharacters } from "../input-sanitization.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { hintForZodIssue, repairToolInput } from "../lib/zod-issues.js";
 import { markInterruptedMessage, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
+import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { classifyProviderError } from "../providers/errors.js";
 import { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "../providers/prompt-cache.js";
 import { resultStep } from "./run-step.js";
@@ -91,6 +92,28 @@ export async function runAgent(agent, initial, session, opts) {
     const logFinish = (level, reason, cappedOut) => {
         log[level]("run finished", { iterations, reason, cappedOut, truncationRecoveries, toolCalls: toolCallCount, toolErrors: toolErrorCount, usage });
     };
+    /**
+     * Settle the transcript on the way out — called at every return. A reply can
+     * carry a complete tool call beside ANY finish reason, because the call
+     * streams before the stop reason arrives, and only the dispatching branches
+     * (`tool-calls`, a call-carrying `stop`, and `length`) run one. A call this
+     * run never dispatched is stripped
+     * rather than executed (a filtered or aborted reply must not act) or answered
+     * with an invented result (the model would read a fabrication as ground
+     * truth). Without the strip, the unanswered call violates the wire contract —
+     * every tool call carries a result — and the provider boundary then refuses
+     * the whole transcript on every later turn of the thread. Scoped past
+     * `initial`: the caller's prefix is not this run's to repair.
+     */
+    const settleTranscript = () => {
+        const droppedCalls = stripUnansweredToolCalls(messages, initial.length);
+        if (droppedCalls.length === 0)
+            return;
+        log.warn("undispatched tool calls stripped at run exit", {
+            toolCallIds: droppedCalls.map((d) => d.toolCallId),
+            tools: droppedCalls.map((d) => d.toolName),
+        });
+    };
     const usageRecorder = opts.usageRecorder ?? createNoopUsageRecorder();
     /**
      * Fold one completed call into both rollups and hand it to the recorder.
@@ -135,6 +158,7 @@ export async function runAgent(agent, initial, session, opts) {
     // lands in a dispatch round — after the concurrent siblings in that same round
     // have completed and been appended. Mirrors the clean-stop terminal path.
     const stopOnDenial = async (i) => {
+        settleTranscript();
         await emit({ type: "iteration", source, index: i, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
         logFinish("warn", "denied", false);
@@ -195,6 +219,7 @@ export async function runAgent(agent, initial, session, opts) {
         return errored;
     };
     const stopOnResolved = async (i) => {
+        settleTranscript();
         await emit({ type: "iteration", source, index: i, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
         return { messages, finish: { reason: "stop", cappedOut: false, truncationRecoveries } };
@@ -266,11 +291,32 @@ export async function runAgent(agent, initial, session, opts) {
                 return stopOnResolved(i);
             continue;
         }
-        if (reply.finishReason !== "tool-calls") {
+        // A local model behind an OpenAI-compatible server routinely labels a
+        // tool-calling reply `stop`. The calls are complete and the model waits
+        // on their results, thus the mislabeled round dispatches like a
+        // `tool-calls` one. Every other terminal keeps the strip: a filtered or
+        // aborted reply must not act.
+        const dispatchesRound = reply.finishReason === "tool-calls" || (reply.finishReason === "stop" && toolCalls.length > 0);
+        if (!dispatchesRound) {
+            settleTranscript();
+            // The settle can remove a call-only aborted partial whole; the
+            // interruption marker then rides the last assistant that survived,
+            // matching the no-output abort contract above.
+            if (reply.finishReason === "aborted")
+                markLastLoopAssistant(messages, initial.length);
             await emit({ type: "iteration", source, index: i, final: true });
             recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
             logFinish("info", reply.finishReason, false);
-            return { messages, finish: { reason: reply.finishReason, cappedOut: false, truncationRecoveries, ...finishUsage() } };
+            return {
+                messages,
+                finish: {
+                    reason: reply.finishReason,
+                    ...(reply.rawFinishReason === undefined ? {} : { rawFinishReason: reply.rawFinishReason }),
+                    cappedOut: false,
+                    truncationRecoveries,
+                    ...finishUsage(),
+                },
+            };
         }
         await emit({ type: "iteration", source, index: i, final: false });
         log.debug("iteration", { iteration: i, tools: toolCalls.map((t) => t.toolName) });
@@ -307,6 +353,7 @@ export async function runAgent(agent, initial, session, opts) {
         // exhausted its iterations, while the reason carries the abort.
         if (assistantHasContent(wrapUp.message))
             messages.push(wrapUp.message);
+        settleTranscript();
         markLastLoopAssistant(messages, initial.length);
         await emit({ type: "iteration", source, index: agent.maxIterations, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: true, usage });
@@ -314,6 +361,7 @@ export async function runAgent(agent, initial, session, opts) {
         return { messages, finish: { reason: "aborted", cappedOut: true, truncationRecoveries, ...finishUsage() } };
     }
     messages.push(wrapUp.message);
+    settleTranscript();
     await emit({ type: "iteration", source, index: agent.maxIterations, final: true });
     recordAgentRun({ agentId: agent.id, iterations, cappedOut: true, usage });
     logFinish("warn", "max_iterations", true);

package/dist/loop/run-to-terminal.d.ts

@@ -2,7 +2,7 @@
  * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
  *
  * Some agents communicate their result EXCLUSIVELY through a terminal tool
- * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * (`submit_plan`, `submit_profile`, `submit_synthesis`, …):
  * the loop's text reply is discarded and the outcome is read from a closure
  * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
  * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —

package/dist/loop/run-to-terminal.js

@@ -2,7 +2,7 @@
  * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
  *
  * Some agents communicate their result EXCLUSIVELY through a terminal tool
- * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * (`submit_plan`, `submit_profile`, `submit_synthesis`, …):
  * the loop's text reply is discarded and the outcome is read from a closure
  * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
  * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —

package/dist/memory/card-builders.d.ts

@@ -39,14 +39,6 @@ export interface RunCardData {
     title: string;
     stepCount: number;
 }
-export interface PreviewCardData {
-    id: string;
-    previewId: string;
-    version: number;
-    title: string;
-    previewPath: string;
-    format: "html" | "pdf";
-}
 /** Build the `data-plan` payload by loading the stored plan. `ok(null)` when
  *  the plan is missing or no longer parses (absence is NOT an error) — the
  *  caller falls back to a chip. */
@@ -100,22 +92,3 @@ export declare function fileGroupHash(paths: string[], title: string | undefined
  * path the live tool rejected would be resurrected into a card on reload.
  */
 export declare function buildFileReferenceCardData(input: Record<string, unknown>): FileReferenceCardData | null;
-/**
- * Build the `data-report-preview` payload for an `iterate_report` tool_use. The
- * preview's source of truth is the filesystem under
- * `previews/{previewId}/`: directory layout yields `version`
- * (latest `vN`) + `previewPath`, and `preview-meta.json` yields title/format.
- * Mirrors `buildRunCardData` — the live emit knows the server-generated
- * `previewId`, while the reconstruct-on-read path resolves it (from the
- * iteration's `previewId` input, or else the analysis's latest preview). The
- * card is keyed by `previewId` only, so every iteration's tool_use rebuilds
- * the same card and the frontend groups them into one with all versions selectable.
- * Null when nothing renders — the caller falls back to a chip.
- */
-export declare function buildPreviewCardData(
-/** Absolute host root of the analysis's workspace tree (previews live inside it). */
-workspaceRoot: string, opts: {
-    previewId?: string;
-    title?: string;
-    format?: "html" | "pdf";
-}): Promise<PreviewCardData | null>;

package/dist/memory/card-builders.js

@@ -16,17 +16,12 @@
  * under the part `type` directly.
  */
 import { createHash } from "node:crypto";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
 import { okAsync } from "neverthrow";
 import { tryQuery } from "../lib/db-result.js";
-import { tryFs } from "../lib/fs-result.js";
 import { AnalysisPlanSchema } from "../schemas/workflow-state.js";
 import { loadPlan } from "../state/index.js";
 import { normalizeEchartSpec } from "../tools/display/normalize-echart-spec.js";
 import { validatePath } from "../tools/lib/path-validation.js";
-import { latestPreviewVersion, previewDir, PREVIEWS_ROOT } from "../workspace/paths.js";
-const PREVIEW_META_FILE = "preview-meta.json";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -176,73 +171,3 @@ export function buildFileReferenceCardData(input) {
     const id = `pres-${fileGroupHash(files.map((f) => f.path), title)}`;
     return { id, ...(title !== undefined ? { title } : {}), files };
 }
-/** The stored preview metadata, or `null` when the file is absent — a malformed
- *  file is a genuine read failure (`err`), folded to `null` at the call site. */
-function readPreviewMeta(previewRootAbs) {
-    const path = join(previewRootAbs, PREVIEW_META_FILE);
-    return tryFs("cardBuilders.readPreviewMeta", async () => JSON.parse(await readFile(path, "utf8")), { path, onAbsent: () => null });
-}
-/** Directory names (not files) directly under `dir`, or `[]` when absent. */
-function subdirs(dir) {
-    return tryFs("cardBuilders.subdirs", async () => (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name), {
-        path: dir,
-        onAbsent: () => [],
-    });
-}
-/** The most-recently-modified previewId under an analysis, or null when none. */
-function latestPreviewId(previewsRootAbs) {
-    return subdirs(previewsRootAbs).map(async (dirs) => {
-        if (dirs.length <= 1)
-            return dirs[0] ?? null;
-        let best = null;
-        for (const name of dirs) {
-            const path = join(previewsRootAbs, name);
-            const mtimeMs = await tryFs("cardBuilders.latestPreviewId.stat", async () => (await stat(path)).mtimeMs, { path }).unwrapOr(null); // skip an unreadable/absent entry
-            if (mtimeMs !== null && (!best || mtimeMs > best.mtimeMs)) {
-                best = { name, mtimeMs };
-            }
-        }
-        return best?.name ?? dirs[0];
-    });
-}
-/**
- * Build the `data-report-preview` payload for an `iterate_report` tool_use. The
- * preview's source of truth is the filesystem under
- * `previews/{previewId}/`: directory layout yields `version`
- * (latest `vN`) + `previewPath`, and `preview-meta.json` yields title/format.
- * Mirrors `buildRunCardData` — the live emit knows the server-generated
- * `previewId`, while the reconstruct-on-read path resolves it (from the
- * iteration's `previewId` input, or else the analysis's latest preview). The
- * card is keyed by `previewId` only, so every iteration's tool_use rebuilds
- * the same card and the frontend groups them into one with all versions selectable.
- * Null when nothing renders — the caller falls back to a chip.
- */
-export async function buildPreviewCardData(
-/** Absolute host root of the analysis's workspace tree (previews live inside it). */
-workspaceRoot, opts) {
-    const previewsRootAbs = join(workspaceRoot, PREVIEWS_ROOT);
-    const resolveId = opts.previewId ? okAsync(opts.previewId) : latestPreviewId(previewsRootAbs);
-    return resolveId
-        .andThen((previewId) => {
-        if (!previewId)
-            return okAsync(null);
-        const previewRootAbs = join(workspaceRoot, previewDir(previewId));
-        return subdirs(previewRootAbs).andThen((versionDirs) => {
-            const version = latestPreviewVersion(versionDirs);
-            if (version === 0)
-                return okAsync(null);
-            return readPreviewMeta(previewRootAbs).map((meta) => {
-                const id = `prev-${createHash("sha256").update(previewId).digest("hex").slice(0, 16)}`;
-                return {
-                    id,
-                    previewId,
-                    version,
-                    title: opts.title ?? meta?.title ?? "Report",
-                    previewPath: `v${version}/index.html`,
-                    format: opts.format ?? (meta?.format === "pdf" ? "pdf" : "html"),
-                };
-            });
-        });
-    })
-        .unwrapOr(null);
-}

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

@@ -1,9 +1,7 @@
 import type { Pool } from "pg";
 import type { Tool } from "../tools/define-tool.js";
-import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 export interface ConversationDisplayBackfillDeps {
     readonly pool: Pool;
-    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
     /**
      * The conversation agent's composed roster, used to recover each legacy call's
      * one-line detail from its persisted input. Tools contributed through the
@@ -17,8 +15,8 @@ export interface ConversationDisplayBackfillDeps {
  * 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 workspace
- * that has moved is normal historical absence, not a fault. Malformed stored rows
+ * 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.
  */

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

@@ -10,8 +10,8 @@ const GENUINE_USER_SQL = `m.message_envelope->'message'->>'role' = 'user'
  * 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 workspace
- * that has moved is normal historical absence, not a fault. Malformed stored rows
+ * 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.
  */
@@ -64,13 +64,7 @@ export async function backfillConversationDisplayEnvelopes(deps) {
             });
             let resolveCard;
             if (head.analysis_id !== null) {
-                try {
-                    resolveCard = createCardResolver(deps.pool, head.analysis_id, deps.resolveWorkspaceRoot(head.analysis_id));
-                }
-                catch {
-                    // A removed/moved workspace is normal historical absence.
-                    resolveCard = undefined;
-                }
+                resolveCard = createCardResolver(deps.pool, head.analysis_id);
             }
             const cortex = await contentToCortexMessages(stored, { resolveCard, resolveDetail });
             const uiMessages = cortexMessagesToConversationUI(cortex);

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

@@ -15,7 +15,7 @@
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
-import type { AskPart, FileReferencePart, PlanPart, PresentationPart, PreviewPart, DataPreviewFailedPart, RunCardPart } from "../contracts/chat-parts.js";
+import type { AskPart, ChildSessionStartedPart, 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";
 export declare const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
@@ -38,8 +38,8 @@ export type ConversationUIData = {
     "run-card": Payload<RunCardPart>;
     "file-reference": Payload<FileReferencePart>;
     ask: Payload<AskPart>;
-    "report-preview": Payload<PreviewPart>;
-    "report-preview-failed": Payload<DataPreviewFailedPart>;
+    "child-session-started": Payload<ChildSessionStartedPart>;
+    "report-rendered": Payload<ReportRenderedPart>;
 };
 export interface ConversationDisplayMetadata {
     interrupted?: boolean;

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

@@ -16,7 +16,7 @@
  */
 import { validateUIMessages } from "ai";
 import { z } from "zod";
-import { AskPartSchema, DataPreviewFailedPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, PreviewPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
+import { AskPartSchema, ChildSessionStartedPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, ReportRenderedPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
 import { ToolCallOutcomeSchema } from "../contracts/schemas/chat-events.js";
 export const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 const DisplayEnvelopeHeaderSchema = z.object({
@@ -54,8 +54,8 @@ const dataSchemas = {
     "run-card": RunCardPartSchema.omit({ type: true }).strict(),
     "file-reference": FileReferencePartSchema.omit({ type: true }).strict(),
     ask: AskPartSchema.omit({ type: true }).strict(),
-    "report-preview": PreviewPartSchema.omit({ type: true }).strict(),
-    "report-preview-failed": DataPreviewFailedPartSchema.omit({ type: true }).strict(),
+    "child-session-started": ChildSessionStartedPartSchema.omit({ type: true }).strict(),
+    "report-rendered": ReportRenderedPartSchema.omit({ type: true }).strict(),
 };
 export function envelopeDisplayMessages(messages) {
     if (messages.length === 0)

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

@@ -4,15 +4,13 @@
  * 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` / `iterate_report` emit
- * `data-plan` / `data-presentation` / `data-file-reference` / `data-run-card` /
- * `data-report-preview` cards
+ * `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) or
- * the analysis's workspace root (preview, filesystem-backed) so the card can
- * be re-loaded.
+ * 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";
@@ -26,4 +24,4 @@ export interface StoredToolCallForCard {
 /** @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, workspaceRoot: string): ToolCardResolver;
+export declare function createCardResolver(pool: Pool, analysisId: string): ToolCardResolver;

package/dist/memory/reconstruct-cards.js

@@ -4,38 +4,24 @@
  * 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` / `iterate_report` emit
- * `data-plan` / `data-presentation` / `data-file-reference` / `data-run-card` /
- * `data-report-preview` cards
+ * `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) or
- * the analysis's workspace root (preview, filesystem-backed) so the card can
- * be re-loaded.
+ * 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, buildPreviewCardData, buildRunCardData } from "./card-builders.js";
+import { buildFileReferenceCardData, buildPlanCardData, buildPresentationCardData, buildRunCardData } from "./card-builders.js";
 /** @deprecated Use persisted conversation display envelopes for runtime reads. */
-export function createCardResolver(pool, analysisId, workspaceRoot) {
+export function createCardResolver(pool, analysisId) {
     return async (block) => {
         if (block.type !== "tool_use")
             return null;
         const input = (block.input ?? {});
-        // The report tool is `submit_report`; legacy transcripts carry the
-        // former ids `iterate_report` / `iterateReport` — accept all three. The
-        // brief-carrying field is still `report`, so the card reads identically.
-        if (block.name === "submit_report" || block.name === "iterate_report" || block.name === "iterateReport") {
-            const report = (input.report ?? null);
-            const card = await buildPreviewCardData(workspaceRoot, {
-                previewId: typeof input.previewId === "string" ? input.previewId : undefined,
-                title: report && typeof report.title === "string" ? report.title : undefined,
-                format: input.format === "pdf" || input.format === "html" ? input.format : undefined,
-            });
-            return card ? { type: "data-report-preview", ...card } : null;
-        }
         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

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

@@ -0,0 +1,46 @@
+/**
+ * Transcript integrity for tool calls.
+ *
+ * The wire contract of every provider is that each tool call in an assistant
+ * message has a matching tool result. A transcript that violates it is refused
+ * WHOLE — the AI SDK throws at prompt conversion, and the Anthropic API answers
+ * 400 — so a single unanswered call makes a thread unable to take any further
+ * turn. An unanswered call is a reachable state, not a hypothetical: a reply
+ * can carry a complete tool call beside ANY finish reason, because the call
+ * streams before the stop reason arrives, and only a `tool-calls` (and, for its
+ * leading calls, a `length`) finish dispatches it.
+ *
+ * The repair is a STRIP, never an invented result. A call that was not
+ * dispatched did not happen, and a fabricated result would record an execution
+ * that did not occur — the model would read it as ground truth on the next
+ * turn. The prose of the message survives the strip; a message left with
+ * nothing the wire can render disappears entirely.
+ */
+import type { ModelMessage } from "ai";
+/** One tool call removed by {@link stripUnansweredToolCalls}, identified for the caller's diagnostic record. */
+export interface DroppedToolCall {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}
+/**
+ * Remove, in place, every tool-call part at or past `fromIndex` that has no
+ * matching tool result anywhere in `messages`. Returns the removed calls in
+ * transcript order — empty on the healthy path — so the caller can log what
+ * a reader of the stored thread would otherwise never learn.
+ *
+ * Results are matched by id across the whole array, not by adjacency: the loop
+ * appends a round's results directly after its assistant message, but a
+ * deferred-image user message can ride between rounds, and the stored shape is
+ * not this function's to assume.
+ *
+ * A message that keeps a text or file part survives the strip — refusal prose
+ * is the one account the reader has of a filtered reply. A message left with
+ * no such part (a call-only message, or reasoning beside the removed call) is
+ * removed whole: reasoning without the output it preceded is not replayable,
+ * and an empty assistant message is itself a wire violation.
+ *
+ * `fromIndex` bounds the REPAIR, not the result scan. The loop passes its
+ * `initial.length` so it never rewrites the caller's prefix; the assembly
+ * repair passes nothing and covers the whole stored window.
+ */
+export declare function stripUnansweredToolCalls(messages: ModelMessage[], fromIndex?: number): DroppedToolCall[];

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

@@ -0,0 +1,92 @@
+/**
+ * Transcript integrity for tool calls.
+ *
+ * The wire contract of every provider is that each tool call in an assistant
+ * message has a matching tool result. A transcript that violates it is refused
+ * WHOLE — the AI SDK throws at prompt conversion, and the Anthropic API answers
+ * 400 — so a single unanswered call makes a thread unable to take any further
+ * turn. An unanswered call is a reachable state, not a hypothetical: a reply
+ * can carry a complete tool call beside ANY finish reason, because the call
+ * streams before the stop reason arrives, and only a `tool-calls` (and, for its
+ * leading calls, a `length`) finish dispatches it.
+ *
+ * The repair is a STRIP, never an invented result. A call that was not
+ * dispatched did not happen, and a fabricated result would record an execution
+ * that did not occur — the model would read it as ground truth on the next
+ * turn. The prose of the message survives the strip; a message left with
+ * nothing the wire can render disappears entirely.
+ */
+/**
+ * Whether this tool call needs a client-supplied result. A provider-executed
+ * call is answered by the provider inside the same assistant message, so the
+ * wire contract makes no demand on the client for it — the AI SDK's own
+ * missing-result validation skips these, and so does the strip.
+ */
+function needsClientResult(part) {
+    return part.providerExecuted !== true;
+}
+/**
+ * Remove, in place, every tool-call part at or past `fromIndex` that has no
+ * matching tool result anywhere in `messages`. Returns the removed calls in
+ * transcript order — empty on the healthy path — so the caller can log what
+ * a reader of the stored thread would otherwise never learn.
+ *
+ * Results are matched by id across the whole array, not by adjacency: the loop
+ * appends a round's results directly after its assistant message, but a
+ * deferred-image user message can ride between rounds, and the stored shape is
+ * not this function's to assume.
+ *
+ * A message that keeps a text or file part survives the strip — refusal prose
+ * is the one account the reader has of a filtered reply. A message left with
+ * no such part (a call-only message, or reasoning beside the removed call) is
+ * removed whole: reasoning without the output it preceded is not replayable,
+ * and an empty assistant message is itself a wire violation.
+ *
+ * `fromIndex` bounds the REPAIR, not the result scan. The loop passes its
+ * `initial.length` so it never rewrites the caller's prefix; the assembly
+ * repair passes nothing and covers the whole stored window.
+ */
+export function stripUnansweredToolCalls(messages, fromIndex = 0) {
+    const resultIds = new Set();
+    for (const message of messages) {
+        if (message.role === "tool") {
+            for (const part of message.content) {
+                if (part.type === "tool-result")
+                    resultIds.add(part.toolCallId);
+            }
+        }
+        else if (message.role === "assistant" && typeof message.content !== "string") {
+            for (const part of message.content) {
+                if (part.type === "tool-result")
+                    resultIds.add(part.toolCallId);
+            }
+        }
+    }
+    const dropped = [];
+    // Backward, so a whole-message removal cannot shift an index this loop has
+    // yet to visit.
+    for (let idx = messages.length - 1; idx >= fromIndex; idx--) {
+        const message = messages[idx];
+        if (message.role !== "assistant" || typeof message.content === "string")
+            continue;
+        const removed = [];
+        for (const part of message.content) {
+            if (part.type === "tool-call" && needsClientResult(part) && !resultIds.has(part.toolCallId))
+                removed.push(part);
+        }
+        if (removed.length === 0)
+            continue;
+        // Prepended as a batch: the walk visits messages tail-first, but the
+        // caller's record reads in transcript order.
+        dropped.unshift(...removed.map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName })));
+        const removedParts = new Set(removed);
+        const kept = message.content.filter((part) => !removedParts.has(part));
+        if (kept.some((part) => part.type === "text" || part.type === "file" || part.type === "tool-call" || part.type === "tool-result")) {
+            messages[idx] = { ...message, content: kept };
+        }
+        else {
+            messages.splice(idx, 1);
+        }
+    }
+    return dropped;
+}

package/dist/runtime/boot.js

@@ -38,7 +38,6 @@
  */
 import { unwrapOrThrow } from "../lib/result.js";
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
-import { REPORT_BUILDER_AGENT_ID, REPORT_BUILDER_SKILLS } from "../agents/report-builder.js";
 import { validateAgentSkills } from "../agents/sandbox/validate-skills.js";
 import { initCortexState } from "../state/init.js";
 import { backfillConversationDisplayEnvelopes } from "../memory/conversation-display-backfill.js";
@@ -49,16 +48,8 @@ import { markDraining } from "./lifecycle.js";
 import { runShutdownSequence } from "./shutdown.js";
 const noop = () => { };
 const noopAsync = () => Promise.resolve();
-/**
- * Every agent whose declared packs must resolve before the first run. The
- * report-builder is not in the sandbox catalog — it is not plannable — but it
- * declares a pack all the same, and a missing one there surfaces as a failed
- * render partway through a report rather than at boot.
- */
-const SKILL_DECLARING_AGENTS = {
-    ...SANDBOX_AGENT_META,
-    [REPORT_BUILDER_AGENT_ID]: { id: REPORT_BUILDER_AGENT_ID, skills: REPORT_BUILDER_SKILLS },
-};
+/** Every agent whose declared packs must resolve before the first run. */
+const SKILL_DECLARING_AGENTS = SANDBOX_AGENT_META;
 export async function bootHarness(deps) {
     const { core, pool, skillsDir, logger } = deps;
     (deps.initTelemetry ?? noop)();
@@ -73,7 +64,6 @@ export async function bootHarness(deps) {
     const conversationAgent = unwrapOrThrow(runtime.agents.forThread("conversation"));
     await backfillConversationDisplayEnvelopes({
         pool,
-        resolveWorkspaceRoot: core.conversation.resolveWorkspaceRoot,
         tools: conversationAgent.tools,
     });
     await deps.beforeLaunch?.();

package/dist/tools/report-session/preview-report.d.ts

@@ -28,7 +28,8 @@
  * render problem, a figure that escapes the workspace root, a write failure, and a stamp failure. The tool
  * never throws for one of them. When the page
  * lands, the tool stamps the hash of the rendered draft on the session state, thus the eyes and the record
- * know which draft the page shows. The filesystem speaks the
+ * know which draft the page shows. It then emits one durable `data-report-rendered` part, thus the
+ * transcript places the render and a live client learns that a fresh page exists. The filesystem speaks the
  * throw protocol, and the workspace-root seam signals an unresolvable resource the same way. Thus the
  * write runs through the `tryFs` glue, which turns a genuine fault into the ok-channel outcome and lets a
  * control-flow exception propagate.

package/dist/tools/report-session/preview-report.js

@@ -28,12 +28,14 @@
  * render problem, a figure that escapes the workspace root, a write failure, and a stamp failure. The tool
  * never throws for one of them. When the page
  * lands, the tool stamps the hash of the rendered draft on the session state, thus the eyes and the record
- * know which draft the page shows. The filesystem speaks the
+ * know which draft the page shows. It then emits one durable `data-report-rendered` part, thus the
+ * transcript places the render and a live client learns that a fresh page exists. The filesystem speaks the
  * throw protocol, and the workspace-root seam signals an unresolvable resource the same way. Thus the
  * write runs through the `tryFs` glue, which turns a genuine fault into the ok-channel outcome and lets a
  * control-flow exception propagate.
  */
 import { err, ok } from "neverthrow";
+import { randomUUID } from "node:crypto";
 import { copyFile, mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { extname, join } from "node:path";
 import { relative as relativePosix } from "node:path/posix";
@@ -475,6 +477,12 @@ export function createPreviewReportTool(deps) {
                 logger.warn("the rendered hash did not stamp", { threadId, analysisId, detail });
                 return ok({ outcome: "stamp-failed", pagePath: written.value, detail });
             }
+            // The part rides the rendered arm only. Each degraded arm shows no
+            // fresh page, thus it emits nothing.
+            await ctx.emit({
+                type: "data-report-rendered",
+                data: { id: randomUUID(), renderedAt: new Date().toISOString(), title: document.title },
+            });
             const access = await mintAccess(deps.makeSessionPages, analysisId, threadId, ctx.session.auth, logger);
             return ok({ outcome: "rendered", pagePath: written.value, ...(access !== undefined ? { access } : {}) });
         },