@inflexa-ai/harness 0.39.2 → 0.40.0

package/dist/tools/sandbox/report-blocker.js

@@ -6,18 +6,24 @@
  * `report_blocker` is the alternative to improvising an inline result the
  * harness would launder into a green run.
  *
- * This module is the canonical home of the tool. Three loops offer it — the
- * sandbox step agent, the planner (`tools/research/generate-plan.ts`) and the
- * run synthesizer (`execution/run-synthesis.ts`) — and all three share one id,
+ * This module is the canonical home of the tool. Four loops offer it — the
+ * sandbox step agent, the planner (`tools/research/generate-plan.ts`), the
+ * run synthesizer (`execution/run-synthesis.ts`) and the analogical reasoner
+ * (`tools/research/generate-analogy-report.ts`) — and all four share one id,
  * one input schema and one terminal contract via `createReportBlockerToolFor`.
  * What differs per loop is only what a blocker *means* there, so each call site
  * injects its own `blockedWhen` prose and its own capture closure. The tool
- * records the reason and tells the agent to stop; the driving body reads its
- * own outcome cell after the loop and decides the terminal status.
+ * records the reason and tells the agent to stop; the driving body reads the
+ * outcome after the loop and decides the terminal status. The sandbox step body
+ * runs in durable steps, so it reads the blocker back from the transcript
+ * (`recordedBlocker`) on replay, not only from its cell.
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
+import { repairToolInput } from "../../lib/zod-issues.js";
+import { toolOutcomeForOutputType } from "../../loop/tool-outcome.js";
 import { defineTool } from "../define-tool.js";
+export const REPORT_BLOCKER_TOOL_ID = "report_blocker";
 export function createBlockerHolder() {
     return { outcome: null };
 }
@@ -30,7 +36,7 @@ const ReportBlockerInputSchema = z.object({ reason: z.string().min(1) });
  */
 export function createReportBlockerToolFor(deps) {
     return defineTool({
-        id: "report_blocker",
+        id: REPORT_BLOCKER_TOOL_ID,
         description: `Terminal. ${deps.blockedWhen} Pass a clear reason. Stop immediately after calling — take no further actions.`,
         inputSchema: ReportBlockerInputSchema,
         describeCall: "none",
@@ -43,6 +49,48 @@ export function createReportBlockerToolFor(deps) {
         },
     });
 }
+/**
+ * The blocker that a run recorded, read from its transcript: the reason of the
+ * first `report_blocker` call, in call order, whose result is ok.
+ *
+ * A replay returns each tool step's cached result without re-running
+ * `execute`, so the in-memory cell is empty on replay; the transcript is not.
+ */
+export function recordedBlocker(messages) {
+    const recorded = new Set();
+    for (const message of messages) {
+        if (message.role !== "tool")
+            continue;
+        for (const part of message.content) {
+            if (part.type === "tool-result" && part.toolName === REPORT_BLOCKER_TOOL_ID && toolOutcomeForOutputType(part.output.type) === "ok") {
+                recorded.add(part.toolCallId);
+            }
+        }
+    }
+    for (const message of messages) {
+        if (message.role !== "assistant" || typeof message.content === "string")
+            continue;
+        for (const part of message.content) {
+            if (part.type !== "tool-call" || part.toolName !== REPORT_BLOCKER_TOOL_ID || !recorded.has(part.toolCallId))
+                continue;
+            const reason = blockerReason(part.input);
+            if (reason !== undefined)
+                return { kind: "blocker", reason };
+        }
+    }
+    return null;
+}
+/** The reason of a `report_blocker` input, validated as the dispatch validates it. */
+function blockerReason(input) {
+    const parsed = ReportBlockerInputSchema.safeParse(input);
+    if (parsed.success)
+        return parsed.data.reason;
+    const repaired = repairToolInput(input, parsed.error);
+    if (repaired === undefined)
+        return undefined;
+    const reparsed = ReportBlockerInputSchema.safeParse(repaired);
+    return reparsed.success ? reparsed.data.reason : undefined;
+}
 /**
  * The sandbox step agent's `report_blocker`, bound to the step body's holder.
  * A blocker here ends the step with no deliverables and a blocked reason.

package/dist/tools/sandbox/submit-file-metadata.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `submit_file_metadata` — the output tool of the file-metadata continuation of
+ * a sandbox step (see the harness-sandbox-agents spec).
+ *
+ * Each step agent declares this tool from its first request; a mask refuses it
+ * until the file-metadata continuation, because the tool set sits in the
+ * prefix that the prompt cache and a signed thinking block bind to.
+ *
+ * The tool matches each description to its file BY PATH, never by array
+ * index, so a dropped, reordered, or extra entry can never attach a
+ * description to the wrong file.
+ */
+import { type SubmittedFileDescription } from "../../schemas/file-metadata.js";
+import { type Tool } from "../define-tool.js";
+export declare const SUBMIT_FILE_METADATA_TOOL_ID = "submit_file_metadata";
+/**
+ * The per-step cell of the file-metadata continuation. The step body makes it
+ * beside the blocker cell, and the agent factory binds the output tool to it.
+ */
+export interface FileMetadataCell {
+    /** The paths that the continuation describes, or `null` before the first `expect`. */
+    readonly knownPaths: ReadonlySet<string> | null;
+    /** The accepted description of each described path, keyed by the path. The tool writes only a known path. */
+    readonly descriptions: Map<string, SubmittedFileDescription>;
+    /** Arm the cell for one continuation: set the known paths, and drop each accepted description. */
+    expect(paths: readonly string[]): void;
+}
+export declare function createFileMetadataCell(): FileMetadataCell;
+/** Build the `submit_file_metadata` tool bound to the cell of one step. */
+export declare function createSubmitFileMetadataTool(cell: FileMetadataCell): Tool;

package/dist/tools/sandbox/submit-file-metadata.js

@@ -0,0 +1,67 @@
+/**
+ * `submit_file_metadata` — the output tool of the file-metadata continuation of
+ * a sandbox step (see the harness-sandbox-agents spec).
+ *
+ * Each step agent declares this tool from its first request; a mask refuses it
+ * until the file-metadata continuation, because the tool set sits in the
+ * prefix that the prompt cache and a signed thinking block bind to.
+ *
+ * The tool matches each description to its file BY PATH, never by array
+ * index, so a dropped, reordered, or extra entry can never attach a
+ * description to the wrong file.
+ */
+import { err, ok } from "neverthrow";
+import { SubmitFileMetadataInputSchema } from "../../schemas/file-metadata.js";
+import { defineTool } from "../define-tool.js";
+export const SUBMIT_FILE_METADATA_TOOL_ID = "submit_file_metadata";
+export function createFileMetadataCell() {
+    let knownPaths = null;
+    const descriptions = new Map();
+    return {
+        get knownPaths() {
+            return knownPaths;
+        },
+        descriptions,
+        expect(paths) {
+            knownPaths = new Set(paths);
+            descriptions.clear();
+        },
+    };
+}
+/** Build the `submit_file_metadata` tool bound to the cell of one step. */
+export function createSubmitFileMetadataTool(cell) {
+    return defineTool({
+        id: SUBMIT_FILE_METADATA_TOOL_ID,
+        description: "Submit the metadata of the output files of this step. The harness asks " +
+            "for this tool after the task, with the list of the files. It does not " +
+            "run during the task. Each entry's `path` MUST exactly match one of the " +
+            "listed files. Returns {accepted, unknownPaths, remaining}: " +
+            "accepted=true means every file now has metadata — STOP. Otherwise drop " +
+            "the unknownPaths and describe the remaining files.",
+        inputSchema: SubmitFileMetadataInputSchema,
+        describeCall: "none",
+        execute: async (input) => {
+            const knownPaths = cell.knownPaths;
+            if (knownPaths === null) {
+                return err({
+                    error: "No list of files is known yet. The harness asks for the file metadata after the task, with the list of the files.",
+                    retryable: false,
+                });
+            }
+            const unknownPaths = [];
+            for (const entry of input.files) {
+                if (!knownPaths.has(entry.path)) {
+                    unknownPaths.push(entry.path);
+                    continue;
+                }
+                cell.descriptions.set(entry.path, entry);
+            }
+            const remaining = [...knownPaths].filter((path) => !cell.descriptions.has(path));
+            return ok({
+                accepted: unknownPaths.length === 0 && remaining.length === 0,
+                unknownPaths,
+                remaining,
+            });
+        },
+    });
+}

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

@@ -45,7 +45,7 @@ export type StartReportSessionInput = z.infer<typeof startReportSessionInput>;
  * never throws for a degraded condition.
  *
  * `started` and `existing-session` name a report thread. `refused` names a call
- * whose scope carries no conversation thread. The four refusals of the spawn
+ * whose scope carries no conversation thread. The three refusals of the spawn
  * keep their own names, thus the agent reads one reason from the spawn and from
  * the tool alike. `failed` is a store fault, and it carries a short line.
  */
@@ -68,8 +68,6 @@ export type StartReportSessionResult = {
 } | {
     outcome: "parent_not_a_conversation";
     threadType: ThreadType;
-} | {
-    outcome: "empty_parent_transcript";
 } | {
     outcome: "failed";
     detail: string;

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

@@ -79,8 +79,6 @@ function toOutcome(fault) {
             return { outcome: "parent_not_found" };
         case "parent_not_a_conversation":
             return { outcome: "parent_not_a_conversation", threadType: fault.threadType };
-        case "empty_parent_transcript":
-            return { outcome: "empty_parent_transcript" };
         case "query_failed":
         case "mutation_failed":
         case "connection_failed":

package/dist/tools/workspace/execute-command.js

@@ -24,7 +24,7 @@ import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { feedExecFrame } from "../../provenance/exec-frame.js";
-import { boundExecResult } from "./result-bounds.js";
+import { EXEC_STREAM_BYTE_CAP, boundExecResult } from "./result-bounds.js";
 import { runSandboxExec } from "./run-exec.js";
 import { createNoopLogger } from "../../lib/console-logger.js";
 const ExecuteCommandInputSchema = z.object({
@@ -32,7 +32,8 @@ const ExecuteCommandInputSchema = z.object({
         .array(z.string().min(1))
         .min(1)
         .describe("argv array — e.g. ['python', 'scripts/run.py'] or ['head', '-n', '50', 'data/inputs/x.csv']. " +
-        "Not passed through a shell; quoting and globbing are not expanded."),
+        "A one-element array runs through `sh -c`, so pipes, `&&`, quoting, and globbing work; " +
+        "an array of two or more elements runs directly, with no shell, and nothing is expanded."),
     cwd: z
         .string()
         .optional()
@@ -57,8 +58,10 @@ export function createExecuteCommandTool(deps) {
         executionMode: "workflow",
         description: "Run a command in the sandbox and return its stdout/stderr/exit code. " +
             "Use for scripts, CLI tools, shell pipes, and anything the workspace " +
-            "tools don't express. stdout and stderr are each capped at 8 KiB; oversize " +
-            "streams come back with truncation markers. Failures are returned as data, " +
+            `tools don't express. stdout and stderr are each capped at ${EXEC_STREAM_BYTE_CAP / (1024 * 1024)} MiB; the end ` +
+            "of a longer stream is dropped, and the result carries its truncation flag. A long result comes back as an " +
+            "excerpt of its start and its end, with a reference to read the rest when the harness keeps it. " +
+            "Failures are returned as data, " +
             "not thrown. stdout/stderr are EPHEMERAL and are NOT a deliverable — use " +
             "this to confirm a command ran, not to produce results. Do NOT compute " +
             "analysis results via 'python -c' / inline one-liners and read them from " +

package/dist/tools/workspace/result-bounds.d.ts

@@ -5,9 +5,9 @@
  * shape is uniform across the surface and the cap can be tuned in one
  * place.
  *
- * The cap is well below the loop's overall result budget so a chatty
- * command cannot blow the context window even when stdout AND stderr both
- * cap out at the limit.
+ * The cap bounds the memory of the host and the size of a kept tool output. It
+ * does not keep the context of the model small: the loop cuts a long result into
+ * an excerpt, and it keeps the text for `read_tool_output`.
  *
  * The same value is sent to the sandbox as a retention budget, so the bytes are
  * dropped at the producer and never cross the wire. Capping here as well is not
@@ -15,7 +15,7 @@
  * and this is the boundary that keeps it out of the process either way.
  */
 import type { ExecResult } from "../../sandbox/types.js";
-/** Per-stream cap. 32 KiB — roomy for real output, well under the loop result budget. */
+/** Per-stream cap: the maximum of a kept tool output, thus the host gets each stream that the store can keep. */
 export declare const EXEC_STREAM_BYTE_CAP: number;
 export interface BoundedStream {
     readonly content: string;

package/dist/tools/workspace/result-bounds.js

@@ -5,17 +5,18 @@
  * shape is uniform across the surface and the cap can be tuned in one
  * place.
  *
- * The cap is well below the loop's overall result budget so a chatty
- * command cannot blow the context window even when stdout AND stderr both
- * cap out at the limit.
+ * The cap bounds the memory of the host and the size of a kept tool output. It
+ * does not keep the context of the model small: the loop cuts a long result into
+ * an excerpt, and it keeps the text for `read_tool_output`.
  *
  * The same value is sent to the sandbox as a retention budget, so the bytes are
  * dropped at the producer and never cross the wire. Capping here as well is not
  * redundant: a sandbox image that pre-dates the budget returns the whole stream,
  * and this is the boundary that keeps it out of the process either way.
  */
-/** Per-stream cap. 32 KiB — roomy for real output, well under the loop result budget. */
-export const EXEC_STREAM_BYTE_CAP = 32 * 1024;
+import { TOOL_OUTPUT_KEEP_MAX } from "../../loop/tool-output.js";
+/** Per-stream cap: the maximum of a kept tool output, thus the host gets each stream that the store can keep. */
+export const EXEC_STREAM_BYTE_CAP = TOOL_OUTPUT_KEEP_MAX;
 /**
  * Decode `buf` as UTF-8, dropping a trailing partial sequence rather than
  * letting it decode to U+FFFD. Only the last few bytes can be partial, so the

package/dist/tools/workspace/workspace-search.d.ts

@@ -23,7 +23,7 @@ export declare function fileTargetOf(id: string, metadata: unknown): string | un
 export declare function createWorkspaceSearchTool(pool: Pool, embedding: EmbeddingProvider): import("../define-tool.js").Tool<{
     query: string;
     limit: number;
-    type?: "output" | "input" | "synthesis" | "summary" | "input-group" | "input-dimension" | "input-kind" | undefined;
+    type?: "output" | "input" | "summary" | "synthesis" | "input-group" | "input-dimension" | "input-kind" | undefined;
 }, {
     results: {
         metadata: unknown;

package/dist/workflows/execute-analysis.d.ts

@@ -80,6 +80,7 @@ import type { AnalysisStep } from "../schemas/workflow-state.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
 import type { ProvenanceSeam } from "../provenance/seam.js";
+import type { ToolOutputStore } from "../loop/tool-output.js";
 import type { RunCharge } from "../billing/run-charge.js";
 import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type PlanStep } from "./execute-analysis-scheduler.js";
@@ -245,6 +246,8 @@ export interface ExecuteAnalysisDeps {
      * recorder.
      */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the loops of the run synthesis and of their read tools. */
+    readonly toolOutputStore?: ToolOutputStore;
     /**
      * The provenance seam of the composition. The body reads its run emit member,
      * and it reads no other member.

package/dist/workflows/execute-analysis.js

@@ -354,6 +354,7 @@ export function synthesizeFindings(args) {
         bioKeys: deps.bioKeys,
         citationResolver: deps.citationResolver,
         usageRecorder: deps.usageRecorder,
+        ...(deps.toolOutputStore ? { toolOutputStore: deps.toolOutputStore } : {}),
     }, {
         analysisId,
         runId,

package/dist/workflows/sandbox-step.d.ts

@@ -9,8 +9,9 @@
  *  2. `createSandbox`       — provision the sandbox; persist its handle.
  *  3. `runAgent`            — the harness agent loop. Every LLM and tool
  *                             call inside is its own durableStep.
- *  4. `generateFileMetadata`— post-step LLM call (chunked, slice-to-length).
- *  5. `generateStepSummary` — post-step LLM call producing `output/summary.md`.
+ *  4. `generateFileMetadata`— the file-metadata continuation of the step agent.
+ *  5. `generateStepSummary` — the summary continuation of the step agent,
+ *                             producing `output/summary.md`.
  *  6. `reconcile + register`— write artifact manifest entries to cortex_artifacts.
  *  7. `syncArtifacts`       — register provenance + upload missing file_ids
  *                             via the managed root (scoped to this run+step).
@@ -32,6 +33,7 @@ import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { CitationResolver } from "../citations/types.js";
 import type { AgentDefinition, LoopMessage } from "../loop/types.js";
+import { type ToolOutputStore } from "../loop/tool-output.js";
 import type { AgentChat, EmbeddingProvider } from "../providers/types.js";
 import { type RunSession, type SpawnSession } from "../auth/types.js";
 import type { FileMetadataEntry } from "../execution/artifact-metadata.js";
@@ -41,10 +43,12 @@ import type { SandboxClient } from "../sandbox/client.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import type { ArtifactRegistry } from "../execution/artifact-registry.js";
+import { type StepFileMetadata } from "../execution/post-step-pipeline.js";
 import type { ResourceSpec } from "../config/resource-limits.js";
 import type { SandboxRef } from "../sandbox/types.js";
 import { ProvenanceCollector } from "../provenance/collector.js";
 import { type BlockerHolder } from "../tools/sandbox/report-blocker.js";
+import { type FileMetadataCell } from "../tools/sandbox/submit-file-metadata.js";
 /**
  * Input the parent hands the child. Must be JSON-serialisable — DBOS
  * persists this as the workflow's input row.
@@ -200,13 +204,19 @@ export interface SandboxAgentBuildContext {
      */
     readonly lineageCollector: ProvenanceCollector;
     /**
-     * Per-run blocker cell (see the harness-sandbox-agents spec). The body owns it and reads
-     * `holder.outcome` after `runAgent`; the agent factory adds `report_blocker`
-     * bound to this holder.
+     * Per-run blocker cell that `report_blocker` writes. The body prefers the
+     * blocker read from the transcript and falls back to this cell.
      */
     readonly blockerHolder: BlockerHolder;
+    /**
+     * Cell for the file-metadata continuation. `submit_file_metadata` is
+     * declared up front for prefix stability but masked until then.
+     */
+    readonly fileMetadata: FileMetadataCell;
     /** Shared host-side citation resolver for allowlisted sandbox agents. */
     readonly citationResolver: CitationResolver;
+    /** Give it to `SandboxAgentDeps.toolOutputStore`: each loop of the step keeps its texts in it. */
+    readonly toolOutputStore?: ToolOutputStore;
 }
 /**
  * Inversion of control: the parent supplies the live agent, the parent's
@@ -226,12 +236,14 @@ export interface SandboxStepDeps {
     readonly logger?: Logger;
     /**
      * LLM usage-accounting seam. Covers this step's agent loop and the
-     * post-step sub-agent loops alike; omitted falls back to the no-op recorder.
+     * post-step continuations alike; omitted falls back to the no-op recorder.
      */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the task, of the two post-step continuations, and of the read tool of the step agent. */
+    readonly toolOutputStore?: ToolOutputStore;
     /** Shared resolver threaded from `assembleCoreRuntime`. */
     readonly citationResolver: CitationResolver;
-    /** Non-streaming chat — drives the agent loop + the post-step sub-agents. */
+    /** Non-streaming chat — drives the agent loop + the post-step continuations. */
     readonly provider: AgentChat;
     /** Write-side embedder for the post-step vector index. */
     readonly embedding: EmbeddingProvider;
@@ -242,11 +254,14 @@ export interface SandboxStepDeps {
      * cloud-free build, external provenance ledger in the managed build).
      */
     readonly artifactRegistry: ArtifactRegistry;
-    /** Workspace read seam — backs `read_file` in the metadata + summary loops. */
+    /**
+     * No longer read by the step body; kept because `src/index.ts` exports
+     * this type and an embedder builds it as an object literal.
+     */
     readonly workspaceFs: WorkspaceFilesystem;
     /** Workspace-root resolution seam (see workspace/paths.ts). */
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
-    /** Sandbox model id — provenance label for metadata + summary generation. */
+    /** No longer read by the step body, kept for the same reason as `workspaceFs`. */
     readonly model: string;
     /**
      * Build the agent definition for this step. The parent resolves the
@@ -272,6 +287,10 @@ export interface PostStepContext {
     readonly input: SandboxStepInput;
     readonly session: RunSession;
     readonly transcript: readonly LoopMessage[];
+    /** The step agent of the task: the continuations send its system prompt and its declared tools. */
+    readonly agent: AgentDefinition;
+    /** The cell that the `submit_file_metadata` tool of `agent` records into. */
+    readonly fileMetadata: FileMetadataCell;
     /** Absolute path to the step's writable artifact directory. */
     readonly writePrefix: string;
     /** Sandbox handle id — informational only, used in log lines. */
@@ -279,6 +298,8 @@ export interface PostStepContext {
     /** Same step-scoped collector the agent loop fed each exec frame into. */
     readonly lineageCollector: ProvenanceCollector;
 }
+/** Normalizes a pre-`messages` checkpoint (a bare entries array) for replay. */
+export declare function readStepFileMetadata(checkpoint: StepFileMetadata | readonly FileMetadataEntry[]): StepFileMetadata;
 /**
  * Build the step's lineage collector from its durable input. The agent loop
  * feeds each exec's provenance frame into it; post-step registration reads the

package/dist/workflows/sandbox-step.js

@@ -9,8 +9,9 @@
  *  2. `createSandbox`       — provision the sandbox; persist its handle.
  *  3. `runAgent`            — the harness agent loop. Every LLM and tool
  *                             call inside is its own durableStep.
- *  4. `generateFileMetadata`— post-step LLM call (chunked, slice-to-length).
- *  5. `generateStepSummary` — post-step LLM call producing `output/summary.md`.
+ *  4. `generateFileMetadata`— the file-metadata continuation of the step agent.
+ *  5. `generateStepSummary` — the summary continuation of the step agent,
+ *                             producing `output/summary.md`.
  *  6. `reconcile + register`— write artifact manifest entries to cortex_artifacts.
  *  7. `syncArtifacts`       — register provenance + upload missing file_ids
  *                             via the managed root (scoped to this run+step).
@@ -34,6 +35,8 @@ import { deliverNotice } from "../lib/hooks.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { runAgent } from "../loop/run-agent.js";
 import { durableStep } from "../loop/run-step.js";
+import { maskExcept } from "../loop/tool-mask.js";
+import { READ_TOOL_OUTPUT_TOOL_ID } from "../loop/tool-output.js";
 import { lastExecOutcome } from "../sandbox/exec-outcome.js";
 import { activityForTool, applyTreeDelta, isChatDataPart, sandboxTreeDelta, stepPartId } from "../sandbox/sandbox-step-translate.js";
 import { createDetailResolver } from "../tools/detail-resolver.js";
@@ -43,7 +46,8 @@ import { collectStepOutputs, describeStepRegistrationFailure, generateStepFileMe
 import { mintSandboxIdentity } from "../sandbox/identity.js";
 import { keepSuspendingRefusal } from "../sandbox/sandbox-error.js";
 import { ProvenanceCollector } from "../provenance/collector.js";
-import { createBlockerHolder } from "../tools/sandbox/report-blocker.js";
+import { createBlockerHolder, recordedBlocker } from "../tools/sandbox/report-blocker.js";
+import { createFileMetadataCell, SUBMIT_FILE_METADATA_TOOL_ID } from "../tools/sandbox/submit-file-metadata.js";
 import { cancelSelf, suspensionOfFailure, suspensionOfRefusal, suspensionOfSpawnRefusal } from "./suspension.js";
 /**
  * Fallback when the plan step omits `timeout`. Plans that need 3-hour runs
@@ -69,6 +73,15 @@ function nextFunctionIdFactory() {
     let n = 0;
     return () => `fn-${(n++).toString(36)}`;
 }
+const NO_STEP_FILE_METADATA = { entries: [], messages: [] };
+/** Normalizes a pre-`messages` checkpoint (a bare entries array) for replay. */
+export function readStepFileMetadata(checkpoint) {
+    return isBareEntries(checkpoint) ? { entries: checkpoint, messages: [] } : checkpoint;
+}
+/** `Array.isArray` as a guard that also narrows a readonly array. */
+function isBareEntries(checkpoint) {
+    return Array.isArray(checkpoint);
+}
 /**
  * Map an internal step failure to a user-safe string. Internal detail (file
  * paths, content hashes, managed-root rejection reasons, stack traces) stays in the pod
@@ -210,6 +223,7 @@ export async function runSandboxStepBody(input, deps) {
     // for up to N × `timeoutSeconds`.
     const stepDeadlineMs = (await DBOS.now()) + (input.timeoutSeconds ?? DEFAULT_STEP_TIMEOUT_SECONDS) * 1000;
     const blockerHolder = createBlockerHolder();
+    const fileMetadata = createFileMetadataCell();
     const agent = deps.buildAgent({
         input,
         session,
@@ -220,8 +234,13 @@ export async function runSandboxStepBody(input, deps) {
         deadlineMs: () => stepDeadlineMs,
         lineageCollector,
         blockerHolder,
+        fileMetadata,
         citationResolver: deps.citationResolver,
+        ...(deps.toolOutputStore ? { toolOutputStore: deps.toolOutputStore } : {}),
     });
+    if (deps.toolOutputStore !== undefined && !agent.tools.some((tool) => tool.id === READ_TOOL_OUTPUT_TOOL_ID)) {
+        logger.warn("the step agent declares no read_tool_output, thus its loops keep no text of a cut tool result");
+    }
     // Built over THIS agent's tools, not a shared table: a sandbox agent's roster
     // differs per agent type, and each tool describes its own calls.
     const resolveDetail = createDetailResolver(agent.tools, logger);
@@ -361,10 +380,14 @@ export async function runSandboxStepBody(input, deps) {
             emit,
             runStep: durableStep,
             usageRecorder: deps.usageRecorder,
+            toolOutputStore: deps.toolOutputStore,
             formatStepName: {
                 llm: (iteration) => `llm:${iteration}`,
                 tool: (toolName, toolUseId) => `tool:${toolName}:${toolUseId}`,
             },
+            // The agent declares the output tool of the file-metadata
+            // continuation from its first request, and the task must not use it.
+            toolMask: maskExcept(agent.tools, [SUBMIT_FILE_METADATA_TOOL_ID]),
             isFatalLoopError: (err) => err instanceof DBOSErrors.DBOSWorkflowCancelledError,
         });
         transcript = agentResult.messages;
@@ -421,7 +444,10 @@ export async function runSandboxStepBody(input, deps) {
     // status would attest an empty step. A blocker outcome keeps its own
     // reason. A capped-out step WITH artifacts stays on the completed path,
     // because partial output is real output.
-    const blockerOutcome = blockerHolder.outcome;
+    //
+    // A replay does not rerun `execute`, so the cell is empty then; the
+    // transcript is the durable record and takes precedence over the cell.
+    const blockerOutcome = recordedBlocker(transcript) ?? blockerHolder.outcome;
     const cappedOutEmpty = hitMaxSteps && manifest.length === 0;
     if (blockerOutcome || cappedOutEmpty) {
         const blockedReason = blockerOutcome?.reason ?? CAPPED_OUT_EMPTY_REASON;
@@ -466,6 +492,8 @@ export async function runSandboxStepBody(input, deps) {
         input,
         session,
         transcript,
+        agent,
+        fileMetadata,
         writePrefix,
         sandboxId: sandbox.sandboxId,
         lineageCollector,
@@ -475,12 +503,13 @@ export async function runSandboxStepBody(input, deps) {
     // outputs are checkpointed (see the harness-durable-runtime spec): the conditional terminal emits they
     // gate (`data-step-summary`, file-tree) stay replay-stable and the billed
     // LLM calls are not re-issued on recovery. The remaining stages (walk /
-    // reconcile / sync / index) stay inline — a separate follow-up.
-    const metadataEntries = await safeRunValue(logger, () => DBOS.runStep(() => generateStepFileMetadata(deps, postCtx, manifest), {
+    // reconcile / sync / index) stay inline — a separate follow-up. The
+    // checkpoint keeps the exchange's messages so a replay's prefix matches.
+    const { entries: metadataEntries, messages: metadataMessages } = readStepFileMetadata(await safeRunValue(logger, () => DBOS.runStep(() => generateStepFileMetadata(deps, postCtx, manifest), {
         name: "post-step.generate-file-metadata",
-    }), "post-step.metadata", []);
+    }), "post-step.metadata", NO_STEP_FILE_METADATA));
     await emitActivity("generating-summary", "Summarizing step results");
-    const summary = await safeRunValue(logger, () => DBOS.runStep(() => generateStepSummaryAndWrite(deps, postCtx, manifest), {
+    const summary = await safeRunValue(logger, () => DBOS.runStep(() => generateStepSummaryAndWrite(deps, postCtx, manifest, metadataMessages), {
         name: "post-step.generate-step-summary",
     }), "post-step.summary", undefined);
     // Lineage attestation (registration) is fail-fast (see the artifact-manifest spec): unlike

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.39.2",
+    "version": "0.40.0",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -47,12 +47,12 @@
         "typecheck": "tsc --noEmit"
     },
     "dependencies": {
-        "@ai-sdk/anthropic": "^4.0.53",
-        "@ai-sdk/openai": "^4.0.66",
-        "@ai-sdk/openai-compatible": "^3.0.48",
-        "@ai-sdk/otel": "^1.0.99",
-        "@ai-sdk/provider": "^4.0.14",
-        "@ai-sdk/provider-utils": "5.0.40",
+        "@ai-sdk/anthropic": "^4.0.62",
+        "@ai-sdk/openai": "^4.0.74",
+        "@ai-sdk/openai-compatible": "^3.0.55",
+        "@ai-sdk/otel": "^1.0.113",
+        "@ai-sdk/provider": "^4.0.18",
+        "@ai-sdk/provider-utils": "5.0.47",
         "@anthropic-ai/sdk": "^0.116.0",
         "@dbos-inc/dbos-sdk": "^4.23.6",
         "@fontsource-variable/space-grotesk": "5.1.1",
@@ -69,7 +69,7 @@
         "@opentelemetry/sdk-trace-node": "^2.9.0",
         "@opentelemetry/semantic-conventions": "^1.43.0",
         "ag-grid-community": "36.1.0",
-        "ai": "^7.0.99",
+        "ai": "^7.0.113",
         "cheerio": "^1.2.0",
         "dockerode": "^4.0.12",
         "echarts": "6.1.0",
@@ -95,7 +95,7 @@
         "uuid": "^11.1.1"
     },
     "devDependencies": {
-        "@ai-sdk/amazon-bedrock": "^5.0.82",
+        "@ai-sdk/amazon-bedrock": "^5.0.93",
         "@eslint/js": "^10.0.1",
         "@types/bun": "latest",
         "@types/dockerode": "^3.3.47",

package/dist/providers/anthropic.d.ts

@@ -1,25 +0,0 @@
-/**
- * Compatibility entry point for Anthropic-backed chat.
- *
- * The production provider path is AI SDK-backed; this wrapper preserves the
- * old factory name for embedders while returning the new `ChatProvider` seam.
- */
-import type { Logger } from "../lib/logger.js";
-import { type ProviderHostPolicy } from "./ai-sdk.js";
-import type { ChatProvider, FetchLike } from "./types.js";
-export interface AnthropicProviderDeps extends ProviderHostPolicy {
-    readonly baseURL?: string;
-    readonly token: string;
-    readonly model: string;
-    readonly fetch?: FetchLike;
-    readonly logger?: Logger;
-    /** Output-token ceiling per request. Defaults to `DEFAULT_MAX_OUTPUT_TOKENS`. */
-    readonly maxOutputTokens?: number;
-}
-/**
- * Convenience over the `anthropic` arm of the public `AiSdkProviderConfig`
- * union: it takes the Anthropic connection fields directly (`token` as the api
- * key) and delegates to `createConfiguredAiSdkProvider`. The same construction
- * contract holds — the `model` is bound into the returned provider.
- */
-export declare function createAnthropicProvider(deps: AnthropicProviderDeps): ChatProvider;