@inflexa-ai/harness 0.39.2 → 0.40.0

package/dist/execution/artifact-metadata.d.ts

@@ -1,29 +1,26 @@
 /**
  * Per-step artifact metadata generation — describes a step's output files
- * via a focused `runAgent` tool-call loop on the harness `ChatProvider`.
+ * through a continuation of the step agent's conversation (`continueAgent`)
+ * on the harness `ChatProvider`.
  *
- * Design (mirrors `generate-plan.ts`): the describer agent communicates
- * exclusively through one tool, `submit_file_metadata`, whose `execute`
- * validates every entry's `path` against the known artifact set. Unknown
- * paths (hallucinated files) are rejected with feedback; uncovered files are
- * reported as `remaining` so the model resubmits. Descriptions are matched
- * to files BY PATH — there is no positional array-index alignment, so a
- * dropped, reordered, or extra entry can never attach a description to the
- * wrong file.
+ * The continuation extends the prefix that the task cached, so each signed
+ * thinking block of the task must stay valid across the extension.
+ *
+ * Descriptions match files BY PATH, not by array index, so a dropped,
+ * reordered, or extra entry can never attach to the wrong file.
  *
  * Lossless contract: every input artifact appears in the result exactly
- * once. A file the model never describes (loop budget exhausted, persistent
- * tool errors, model refusal) gets a deterministic fallback description
- * synthesised from its path + inferred type + size. Fallbacks are logged —
- * never silently dropped, never silently chunked out.
+ * once. A file the model never describes gets a deterministic fallback
+ * description, logged, never silently dropped.
  *
  * `Session` is taken explicitly (see the harness-durable-runtime spec) — billing is a compile-time
  * obligation on every provider call.
  */
 import type { AgentSession } from "../auth/types.js";
-import type { LoopMessage } from "../loop/types.js";
+import { type ToolOutputStore } from "../loop/tool-output.js";
+import type { AgentDefinition, LoopMessage } from "../loop/types.js";
 import type { AgentChat } from "../providers/types.js";
-import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
+import { type FileMetadataCell } from "../tools/sandbox/submit-file-metadata.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 export interface ArtifactForMetadata {
@@ -37,28 +34,26 @@ export interface ArtifactForMetadata {
 export interface GenerateFileMetadataOptions {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
-    /** LLM usage-accounting seam for the describer loop; omitted falls back to the no-op recorder. */
+    /** LLM usage-accounting seam for the continuation; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the task, thus the loop of the continuation keeps its texts where the read tool of the agent reads them. */
+    readonly toolOutputStore?: ToolOutputStore;
+    /** The provider of the task, thus each request extends the prefix that the task cached. */
     readonly provider: AgentChat;
     readonly session: AgentSession;
     readonly artifacts: readonly ArtifactForMetadata[];
     readonly resourceId: string;
     /** Extra metadata fields merged into every entry's `metadata`. */
     readonly extraMetadata?: Record<string, unknown>;
-    /** Model id — provenance label only; the provider owns the wire model. */
-    readonly modelId: string;
+    /** The step agent: the continuation sends its system prompt and its declared tools. */
+    readonly agent: AgentDefinition;
+    /** The cell that the `submit_file_metadata` tool of `agent` records into. */
+    readonly cell: FileMetadataCell;
     /**
-     * In-memory step transcript from `runAgent` — gives the describer the
-     * agent's intent so descriptions reflect what the file was produced for.
-     * Optional: empty/absent degrades to path-only describing.
+     * The transcript from `runAgent` that the continuation extends, to
+     * ground each file's description in why the step produced it.
      */
-    readonly messages?: readonly LoopMessage[];
-    /** Workspace read seam — backs the scoped `read_file` tool. */
-    readonly workspaceFs?: WorkspaceFilesystem;
-    /** Absolute host path to the step's writable output tree — `read_file`'s working dir. */
-    readonly workingDir?: string;
-    /** Iteration budget for the describer loop. Defaults to {@link DEFAULT_MAX_ITERATIONS}. */
-    readonly maxIterations?: number;
+    readonly transcript: readonly LoopMessage[];
     readonly signal?: AbortSignal;
 }
 export interface FileMetadataEntry {
@@ -71,10 +66,8 @@ export interface FileMetadataResult {
     readonly indexed: number;
     /** One entry per input artifact (described or fallback), input order. */
     readonly entries: readonly FileMetadataEntry[];
+    /** The continuation's new messages: the request, then its replies. Empty when no continuation ran. */
+    readonly messages: readonly LoopMessage[];
 }
-/**
- * Describe a step's known artifacts via a tool-call loop. Non-fatal: a loop
- * failure or partial coverage degrades to deterministic fallbacks, so the
- * result always carries exactly one entry per input artifact.
- */
+/** Describes a step's known artifacts; a continuation failure degrades to per-file fallbacks rather than throwing. */
 export declare function generateFileMetadata(opts: GenerateFileMetadataOptions): Promise<FileMetadataResult>;

package/dist/execution/artifact-metadata.js

@@ -1,44 +1,33 @@
 /**
  * Per-step artifact metadata generation — describes a step's output files
- * via a focused `runAgent` tool-call loop on the harness `ChatProvider`.
+ * through a continuation of the step agent's conversation (`continueAgent`)
+ * on the harness `ChatProvider`.
  *
- * Design (mirrors `generate-plan.ts`): the describer agent communicates
- * exclusively through one tool, `submit_file_metadata`, whose `execute`
- * validates every entry's `path` against the known artifact set. Unknown
- * paths (hallucinated files) are rejected with feedback; uncovered files are
- * reported as `remaining` so the model resubmits. Descriptions are matched
- * to files BY PATH — there is no positional array-index alignment, so a
- * dropped, reordered, or extra entry can never attach a description to the
- * wrong file.
+ * The continuation extends the prefix that the task cached, so each signed
+ * thinking block of the task must stay valid across the extension.
+ *
+ * Descriptions match files BY PATH, not by array index, so a dropped,
+ * reordered, or extra entry can never attach to the wrong file.
  *
  * Lossless contract: every input artifact appears in the result exactly
- * once. A file the model never describes (loop budget exhausted, persistent
- * tool errors, model refusal) gets a deterministic fallback description
- * synthesised from its path + inferred type + size. Fallbacks are logged —
- * never silently dropped, never silently chunked out.
+ * once. A file the model never describes gets a deterministic fallback
+ * description, logged, never silently dropped.
  *
  * `Session` is taken explicitly (see the harness-durable-runtime spec) — billing is a compile-time
  * obligation on every provider call.
  */
-import { ok } from "neverthrow";
-import { forSubAgent } from "../auth/types.js";
-import { runAgent } from "../loop/run-agent.js";
+import { continueAgent } from "../loop/continue-agent.js";
 import { passthroughStep } from "../loop/run-step.js";
-import { defineTool } from "../tools/define-tool.js";
-import { createReadFileTool } from "../tools/workspace/read-file.js";
-import { composeSystemPrompt } from "../agents/system-prompt.js";
+import { READ_TOOL_OUTPUT_TOOL_ID } from "../loop/tool-output.js";
 import { inferArtifactType } from "../schemas/artifact-manifest.js";
-import { SubmitFileMetadataInputSchema } from "../schemas/file-metadata.js";
+import { SUBMIT_FILE_METADATA_TOOL_ID } from "../tools/sandbox/submit-file-metadata.js";
 import { createNoopLogger } from "../lib/console-logger.js";
-/** Sub-agent identity for the describer loop — provenance only. */
 const DESCRIBER_AGENT_ID = "file-metadata-describer";
-/**
- * Iteration budget: one full submission + a few correction rounds. The
- * fallback backstop means an exhausted budget degrades gracefully rather
- * than dropping files, so the cap stays small.
- */
-const DEFAULT_MAX_ITERATIONS = 8;
-const SYSTEM_PROMPT = `You are a deterministic metadata describer for bioinformatics output files.
+/** Request cap: one submission plus a few correction rounds; an exhausted cap falls back safely. */
+const DESCRIBER_MAX_REQUESTS = 8;
+/** Tool ids the continuation's mask allows; each must be a tool the step agent already declares. */
+const DESCRIBER_TOOLS = [SUBMIT_FILE_METADATA_TOOL_ID, "read_file", "grep", READ_TOOL_OUTPUT_TOOL_ID];
+const DESCRIBER_INSTRUCTIONS = `Your work on this step has ended. Now describe its output files.
 
 You describe files by calling the submit_file_metadata tool. For each file provide:
   - path        — copy the file's path EXACTLY from the list you are given.
@@ -59,60 +48,9 @@ Rules:
     alone is not enough to describe it accurately.
   - Do not guess file contents you cannot infer; a terse, honest description is
     better than a confident wrong one.`;
-function buildPrompt(artifacts) {
+function describerRequest(artifacts) {
     const list = artifacts.map((a) => `- ${a.displayPath}`).join("\n");
-    return `Describe the following output files by calling submit_file_metadata. Copy each \`path\` EXACTLY from this list. Read a file with read_file when its path alone is not enough to describe it accurately:\n\n${list}`;
-}
-/**
- * Drop a trailing partial assistant `tool_use` round from a loop transcript:
- * it has no matching `tool_result`, so prefixing it onto a fresh loop turn
- * would be an invalid message sequence.
- */
-function sanitizeTranscript(messages) {
-    const out = [...messages];
-    while (out.length > 0) {
-        const last = out[out.length - 1];
-        const blocks = Array.isArray(last.content) ? last.content : [];
-        const hasOpenToolUse = last.role === "assistant" && blocks.some((b) => b.type === "tool-call");
-        if (hasOpenToolUse) {
-            out.pop();
-            continue;
-        }
-        break;
-    }
-    return out;
-}
-/**
- * The single describer tool. Accumulates accepted descriptions into
- * `holder` keyed by path; rejects paths outside `knownPaths`. Returns the
- * coverage state the model uses to decide whether to continue.
- */
-function buildSubmitTool(holder, knownPaths) {
-    return defineTool({
-        id: "submit_file_metadata",
-        description: "Submit metadata for output files. 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 unknownPaths = [];
-            for (const entry of input.files) {
-                if (!knownPaths.has(entry.path)) {
-                    unknownPaths.push(entry.path);
-                    continue;
-                }
-                holder.set(entry.path, entry);
-            }
-            const remaining = [...knownPaths].filter((p) => !holder.has(p));
-            return ok({
-                accepted: unknownPaths.length === 0 && remaining.length === 0,
-                unknownPaths,
-                remaining,
-            });
-        },
-    });
+    return `${DESCRIBER_INSTRUCTIONS}\n\nDescribe the following output files by calling submit_file_metadata. Copy each \`path\` EXACTLY from this list. Read a file with read_file when its path alone is not enough to describe it accurately:\n\n${list}`;
 }
 function buildEntry(artifact, desc, extra) {
     const metadata = {
@@ -152,47 +90,47 @@ function fallbackEntry(artifact, extra) {
         metadata: { ...extra, dataType: fileType, format },
     };
 }
-/**
- * Describe a step's known artifacts via a tool-call loop. Non-fatal: a loop
- * failure or partial coverage degrades to deterministic fallbacks, so the
- * result always carries exactly one entry per input artifact.
- */
+/** Describes a step's known artifacts; a continuation failure degrades to per-file fallbacks rather than throwing. */
 export async function generateFileMetadata(opts) {
     const logger = (opts.logger ?? createNoopLogger()).named("artifact-metadata").with({ resourceId: opts.resourceId });
     if (opts.artifacts.length === 0) {
-        return { indexed: 0, entries: [] };
+        return { indexed: 0, entries: [], messages: [] };
     }
-    const knownPaths = new Set(opts.artifacts.map((a) => a.displayPath));
-    const holder = new Map();
-    const tools = [buildSubmitTool(holder, knownPaths)];
-    if (opts.workspaceFs) {
-        tools.push(createReadFileTool(opts.workspaceFs, opts.workingDir));
+    // The mask can let only a declared tool run, and an embedder whose agent
+    // factory gives no cell to the agent declares no output tool.
+    if (!opts.agent.tools.some((tool) => tool.id === SUBMIT_FILE_METADATA_TOOL_ID)) {
+        logger.warn("the step agent declares no submit_file_metadata, thus each file gets a deterministic fallback description", {
+            agentId: opts.agent.id,
+            artifactCount: opts.artifacts.length,
+        });
+        return { indexed: 0, entries: opts.artifacts.map((artifact) => fallbackEntry(artifact, opts.extraMetadata)), messages: [] };
     }
-    const describer = {
-        id: DESCRIBER_AGENT_ID,
-        systemPrompt: composeSystemPrompt(SYSTEM_PROMPT),
-        model: opts.modelId,
-        tools,
-        maxIterations: opts.maxIterations ?? DEFAULT_MAX_ITERATIONS,
-    };
-    const signal = opts.signal ?? new AbortController().signal;
-    const transcript = opts.messages ? sanitizeTranscript(opts.messages) : [];
+    opts.cell.expect(opts.artifacts.map((a) => a.displayPath));
+    let messages = [];
     try {
-        await runAgent(describer, [...transcript, { role: "user", content: buildPrompt(opts.artifacts) }], forSubAgent(opts.session, DESCRIBER_AGENT_ID), {
+        const continued = await continueAgent(opts.agent, opts.transcript, {
+            text: describerRequest(opts.artifacts),
+            mask: { allow: DESCRIBER_TOOLS },
+            maxRequests: DESCRIBER_MAX_REQUESTS,
+            stepNamespace: "file-metadata",
+            accountingAgentId: DESCRIBER_AGENT_ID,
+        }, opts.session, {
             provider: opts.provider,
-            signal,
+            signal: opts.signal ?? new AbortController().signal,
             emit: () => { },
             runStep: passthroughStep,
             usageRecorder: opts.usageRecorder,
+            toolOutputStore: opts.toolOutputStore,
         });
+        messages = continued.messages;
     }
     catch (err) {
-        logger.warn("describer loop failed; using fallbacks", logger.errorFields(err));
+        logger.warn("describer continuation failed; using fallbacks", logger.errorFields(err));
     }
     const entries = [];
     const fallbackPaths = [];
     for (const artifact of opts.artifacts) {
-        const desc = holder.get(artifact.displayPath);
+        const desc = opts.cell.descriptions.get(artifact.displayPath);
         if (desc) {
             entries.push(buildEntry(artifact, desc, opts.extraMetadata));
         }
@@ -208,5 +146,5 @@ export async function generateFileMetadata(opts) {
             fallbackPaths,
         });
     }
-    return { indexed: holder.size, entries };
+    return { indexed: entries.length - fallbackPaths.length, entries, messages };
 }

package/dist/execution/post-step-pipeline.d.ts

@@ -2,7 +2,8 @@
  * The harness's post-step pipeline — the per-step bookkeeping that runs after a sandbox
  * agent loop finishes: describe the output files, write an interpretive
  * summary, reconcile + register the artifact manifest, and index the
- * descriptions into the per-analysis vector store.
+ * descriptions into the per-analysis vector store. The description and the
+ * summary are continuations of the conversation of the step agent.
  *
  * These leaf bodies are host-neutral: the only place an embedder differs is the
  * injected `ArtifactRegistry` (filesystem vs. external provenance) and the
@@ -12,8 +13,9 @@
  */
 import { type Result } from "neverthrow";
 import type { Pool } from "pg";
+import type { ToolOutputStore } from "../loop/tool-output.js";
+import type { LoopMessage } from "../loop/types.js";
 import type { AgentChat, EmbeddingProvider } from "../providers/types.js";
-import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import type { ArtifactManifestEntry } from "../schemas/artifact-manifest.js";
 import type { StepSummary } from "../schemas/step-summary.js";
@@ -31,30 +33,35 @@ export interface PostStepPipelineDeps {
     readonly pool: Pool;
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
-    /** LLM usage-accounting seam for the metadata + summary loops; omitted falls back to the no-op recorder. */
+    /** LLM usage-accounting seam for the metadata + summary continuations; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
-    /** Non-streaming chat — the metadata + summary sub-agent loops. */
+    /** The store of the task, thus a reference of the task stays readable in the metadata + summary continuations. */
+    readonly toolOutputStore?: ToolOutputStore;
+    /** Non-streaming chat — the provider of the task, which the metadata + summary continuations extend. */
     readonly provider: AgentChat;
     /** Write-side embedder for the vector index. */
     readonly embedding: EmbeddingProvider;
-    readonly workspaceFs: WorkspaceFilesystem;
     readonly artifactRegistry: ArtifactRegistry;
     /** Workspace-root resolution seam (see workspace/paths.ts). */
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
-    /** Sandbox model id — provenance label for metadata + summary. */
-    readonly model: string;
 }
+/** The product of the file-metadata stage, as its `DBOS.runStep` checkpoints it. */
+export interface StepFileMetadata {
+    /** One entry per manifest file, described or fallback. */
+    readonly entries: readonly FileMetadataEntry[];
+    /**
+     * The file-metadata exchange's messages, empty if none ran. Checkpointed by
+     * `DBOS.runStep`, so a replay must give the summary the same prefix.
+     */
+    readonly messages: readonly LoopMessage[];
+}
+/** Describes each manifest file; a file the model cannot describe gets a deterministic fallback, never a dropped entry. */
+export declare function generateStepFileMetadata(deps: PostStepPipelineDeps, postCtx: PostStepContext, manifest: readonly ArtifactManifestEntry[]): Promise<StepFileMetadata>;
 /**
- * Describe each manifest file. Returns one entry per file — a file the model
- * fails to describe gets a deterministic fallback, never a dropped entry.
- */
-export declare function generateStepFileMetadata(deps: PostStepPipelineDeps, postCtx: PostStepContext, manifest: readonly ArtifactManifestEntry[]): Promise<readonly FileMetadataEntry[]>;
-/**
- * Generate the interpretive step summary and persist it to
- * `output/summary.md`. A write failure is non-fatal (logged) — the summary is
- * still returned for vector indexing.
+ * Generates the interpretive step summary, continuing after `metadataMessages`,
+ * and writes it to `output/summary.md`. A write failure is non-fatal.
  */
-export declare function generateStepSummaryAndWrite(deps: PostStepPipelineDeps, postCtx: PostStepContext, manifest: readonly ArtifactManifestEntry[]): Promise<StepSummary | undefined>;
+export declare function generateStepSummaryAndWrite(deps: PostStepPipelineDeps, postCtx: PostStepContext, manifest: readonly ArtifactManifestEntry[], metadataMessages: readonly LoopMessage[]): Promise<StepSummary | undefined>;
 export type StepRegistrationFailure = ArtifactRegistrationFailure | {
     readonly kind: "rejected";
     readonly message: string;

package/dist/execution/post-step-pipeline.js

@@ -2,7 +2,8 @@
  * The harness's post-step pipeline — the per-step bookkeeping that runs after a sandbox
  * agent loop finishes: describe the output files, write an interpretive
  * summary, reconcile + register the artifact manifest, and index the
- * descriptions into the per-analysis vector store.
+ * descriptions into the per-analysis vector store. The description and the
+ * summary are continuations of the conversation of the step agent.
  *
  * These leaf bodies are host-neutral: the only place an embedder differs is the
  * injected `ArtifactRegistry` (filesystem vs. external provenance) and the
@@ -22,14 +23,11 @@ import { generateFileMetadata as coreGenerateFileMetadata } from "./artifact-met
 import { generateStepSummary as coreGenerateStepSummary } from "./step-summary.js";
 import { createVectorStore } from "../state/vector-store.js";
 import { ensureSearchIndex, searchIndexName } from "../workspace/search-config.js";
-/**
- * Describe each manifest file. Returns one entry per file — a file the model
- * fails to describe gets a deterministic fallback, never a dropped entry.
- */
+/** Describes each manifest file; a file the model cannot describe gets a deterministic fallback, never a dropped entry. */
 export async function generateStepFileMetadata(deps, postCtx, manifest) {
-    const { input, session, transcript, writePrefix } = postCtx;
+    const { input, session, transcript, agent, fileMetadata } = postCtx;
     if (manifest.length === 0)
-        return [];
+        return { entries: [], messages: [] };
     const dbPathPrefix = `runs/${input.runId}/${input.stepId}/`;
     const artifactsForMeta = manifest.map((a) => ({
         dbPath: `${dbPathPrefix}${a.path}`,
@@ -37,9 +35,14 @@ export async function generateStepFileMetadata(deps, postCtx, manifest) {
         sizeBytes: a.size,
     }));
     const result = await coreGenerateFileMetadata({
+        logger: deps.logger,
         provider: deps.provider,
         usageRecorder: deps.usageRecorder,
+        toolOutputStore: deps.toolOutputStore,
         session,
+        agent,
+        cell: fileMetadata,
+        transcript,
         artifacts: artifactsForMeta,
         resourceId: input.analysisId,
         extraMetadata: {
@@ -48,29 +51,24 @@ export async function generateStepFileMetadata(deps, postCtx, manifest) {
             producerRun: input.runId,
             producerAgent: input.agentId,
         },
-        modelId: deps.model,
-        messages: transcript,
-        workspaceFs: deps.workspaceFs,
-        workingDir: writePrefix,
     });
-    return result.entries;
+    return { entries: result.entries, messages: result.messages };
 }
 /**
- * Generate the interpretive step summary and persist it to
- * `output/summary.md`. A write failure is non-fatal (logged) — the summary is
- * still returned for vector indexing.
+ * Generates the interpretive step summary, continuing after `metadataMessages`,
+ * and writes it to `output/summary.md`. A write failure is non-fatal.
  */
-export async function generateStepSummaryAndWrite(deps, postCtx, manifest) {
-    const { input, session, transcript, writePrefix } = postCtx;
+export async function generateStepSummaryAndWrite(deps, postCtx, manifest, metadataMessages) {
+    const { input, session, transcript, agent, writePrefix } = postCtx;
     const summary = await coreGenerateStepSummary({
+        logger: deps.logger,
         provider: deps.provider,
         usageRecorder: deps.usageRecorder,
+        toolOutputStore: deps.toolOutputStore,
         session,
-        modelId: deps.model,
-        messages: transcript,
+        agent,
+        conversation: [...transcript, ...metadataMessages],
         artifactPaths: manifest.map((a) => a.path),
-        workspaceFs: deps.workspaceFs,
-        workingDir: writePrefix,
         stepId: input.stepId,
         agentId: input.agentId,
         runId: input.runId,

package/dist/execution/run-synthesis.d.ts

@@ -25,6 +25,7 @@
  */
 import { type RunSynthesis } from "../schemas/run-synthesis.js";
 import type { StepSummary } from "../schemas/step-summary.js";
+import type { ToolOutputStore } from "../loop/tool-output.js";
 import type { ChatDataPart, EmitFn } from "../loop/types.js";
 import type { ChatProvider } from "../providers/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
@@ -72,6 +73,8 @@ export interface GenerateRunSynthesisInput {
     readonly citationResolver: CitationResolver;
     /** LLM usage-accounting seam for the synthesizer + reviewer loops; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the synthesizer and reviewer loops and of their read tools. */
+    readonly toolOutputStore?: ToolOutputStore;
     /** Step summaries from the completed run. Non-empty. */
     readonly summaries: readonly StepSummary[];
     /** Plan analytical narrative for context. */

package/dist/execution/run-synthesis.js

@@ -37,6 +37,7 @@ import { decodeObjectString } from "../lib/zod-issues.js";
 import { runToTerminal } from "../loop/run-to-terminal.js";
 import { passthroughStep } from "../loop/run-step.js";
 import { defineTool } from "../tools/define-tool.js";
+import { createReadToolOutputTool } from "../tools/read-tool-output.js";
 import { createReportBlockerToolFor } from "../tools/sandbox/report-blocker.js";
 import { createLiteratureReviewerTool } from "../tools/research/literature-reviewer.js";
 // ── Agent identity / budgets ────────────────────────────────────────
@@ -52,6 +53,11 @@ export const SYNTHESIS_AGENT_ID = "run-synthesizer";
  * + draft + 1–2 submit/fix cycles + headroom.
  */
 const SYNTHESIZER_MAX_ITERATIONS = 25;
+/**
+ * Cap on `literature_reviewer` calls per run. Not named in the prompt: a
+ * model treats a stated call-count limit as a target to hit, not a maximum.
+ */
+const LITERATURE_REVIEWER_BUDGET = 3;
 // ── Validation ──────────────────────────────────────────────────────
 function zodIssuesToValidationIssues(error, input, rootPath = "synthesis") {
     return error.issues.map((i) => ({
@@ -358,11 +364,13 @@ export async function generateRunSynthesis(input) {
         bioKeys: input.bioKeys,
         citationResolver: input.citationResolver,
         usageRecorder: input.usageRecorder,
+        ...(input.toolOutputStore ? { toolOutputStore: input.toolOutputStore } : {}),
     });
     const validateTool = buildValidateTool(innerCtx);
     const submitTool = buildSubmitTool(holder, innerCtx);
     const blockerTool = buildBlockerTool(holder);
-    const tools = [validateTool, submitTool, blockerTool, reviewer];
+    const readTools = input.toolOutputStore ? [createReadToolOutputTool(input.toolOutputStore)] : [];
+    const tools = [validateTool, submitTool, blockerTool, reviewer, ...readTools];
     const agent = {
         id: SYNTHESIS_AGENT_ID,
         systemPrompt: composeSystemPrompt(synthesisAgentPrompt),
@@ -380,6 +388,8 @@ export async function generateRunSynthesis(input) {
         runStep: passthroughStep,
         resolved: () => holder.outcome !== null,
         usageRecorder: input.usageRecorder,
+        toolOutputStore: input.toolOutputStore,
+        toolBudget: { [reviewer.id]: LITERATURE_REVIEWER_BUDGET },
     };
     await runToTerminal(agent, [{ role: "user", content: prompt }], input.session, loopDeps, {
         tools: [submitTool, blockerTool],

package/dist/execution/step-summary.d.ts

@@ -1,61 +1,52 @@
 /**
- * Per-step interpretive markdown summary — a focused `runAgent` tool-loop on
- * the harness `ChatProvider` that consumes the step's in-memory transcript
- * (the `runAgent` `messages` array the workflow body already holds) AND a
- * scoped `read_file` so it grounds every quantitative claim in the persisted
- * output files rather than confabulating from `execute_command` stdout.
+ * Per-step interpretive summary. Continues the step agent's conversation
+ * (`continueAgent`) so the request reuses the cached prefix and keeps
+ * signed thinking blocks valid.
  *
  * Contract:
- *   - `runAgent` loop with a single `read_file` tool scoped to the step's
- *     writable output tree (via `createReadFileTool(workspaceFs, workingDir)`).
- *     The summarizer reads any output file it needs, then emits the markdown
+ *   - Sends the step agent's system prompt and tools, masked to `read_file`
+ *     and `grep` in the step's output tree plus `read_tool_output`, and emits the markdown
  *     summary as its final assistant text.
  *   - Returns `{ stepId, agentId, markdown }` on non-empty final text;
- *     `undefined` on empty/empty-after-trim, on a loop throw, or on no
- *     text in the final assistant turn. Non-fatal — the workflow body decides
- *     whether to write `output/summary.md`.
+ *     `undefined` on empty text, on a throw, or when the request cap is hit
+ *     before a final answer (a continuation runs no wrap-up). Non-fatal.
  *   - `Session` is taken explicitly (see the harness-durable-runtime spec).
  *
- * Honest empty: with no output artifacts the prompt directs the model to
+ * Honest empty: with no output artifacts the request directs the model to
  * state plainly that the step produced no output files — no synthesized
  * results. Blocked steps skip this producer entirely (handled upstream).
  *
  * Transcript-from-memory: per the harness-thread-store spec, workflow loops have no `messages`
  * table; reconstruction from `operation_outputs` is read-side only. At
- * step time the workflow body already holds the array — pass it in.
+ * step time the workflow body already holds the array — pass it in. The task
+ * always closes its unanswered calls, so the transcript needs no repair.
  */
 import type { AgentSession } from "../auth/types.js";
-import type { LoopMessage } from "../loop/types.js";
+import { type ToolOutputStore } from "../loop/tool-output.js";
+import type { AgentDefinition, LoopMessage } from "../loop/types.js";
 import type { AgentChat } from "../providers/types.js";
-import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import { type StepSummary } from "../schemas/step-summary.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 export interface GenerateStepSummaryOptions {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
-    /** LLM usage-accounting seam for the summary loop; omitted falls back to the no-op recorder. */
+    /** LLM usage-accounting seam for the continuation; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the task, thus the loop of the continuation keeps its texts where the read tool of the agent reads them. */
+    readonly toolOutputStore?: ToolOutputStore;
+    /** The provider of the task, thus each request extends the prefix that the task cached. */
     readonly provider: AgentChat;
     readonly session: AgentSession;
-    readonly modelId: string;
-    /** In-memory transcript from `runAgent` — assistant + tool-result rounds. */
-    readonly messages: readonly LoopMessage[];
+    /** The step agent: the continuation sends its system prompt and its declared tools. */
+    readonly agent: AgentDefinition;
+    /** Task transcript, then the file-metadata exchange messages if one ran. */
+    readonly conversation: readonly LoopMessage[];
     readonly artifactPaths: readonly string[];
-    /** Workspace read seam — backs the scoped `read_file` tool. */
-    readonly workspaceFs: WorkspaceFilesystem;
-    /** Absolute host path to the step's writable output tree — `read_file`'s working dir. */
-    readonly workingDir: string;
     readonly stepId: string;
     readonly agentId: string;
     readonly runId: string;
-    readonly maxIterations?: number;
     readonly signal?: AbortSignal;
 }
-/**
- * Run the post-step summary loop on the harness provider against the supplied
- * transcript, grounding claims in persisted files via `read_file`. Returns
- * `undefined` on any non-fatal failure mode; the workflow body proceeds
- * without `summary.md` in that case.
- */
+/** Returns `undefined` on non-fatal failure instead of throwing. */
 export declare function generateStepSummary(opts: GenerateStepSummaryOptions): Promise<StepSummary | undefined>;