@inflexa-ai/harness 0.39.2 → 0.41.0

package/dist/contracts/schemas/chat-parts.d.ts

@@ -204,7 +204,6 @@ export declare const DagStatePartSchema: z.ZodObject<{
 export declare const StepPhaseSchema: z.ZodEnum<{
     failed: "failed";
     complete: "complete";
-    warning: "warning";
     "sandbox-init": "sandbox-init";
     executing: "executing";
     "generating-metadata": "generating-metadata";
@@ -212,6 +211,7 @@ export declare const StepPhaseSchema: z.ZodEnum<{
     indexing: "indexing";
     persisting: "persisting";
     retrying: "retrying";
+    warning: "warning";
 }>;
 export declare const StepActivityPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-step-activity">;
@@ -221,7 +221,6 @@ export declare const StepActivityPartSchema: z.ZodObject<{
     phase: z.ZodEnum<{
         failed: "failed";
         complete: "complete";
-        warning: "warning";
         "sandbox-init": "sandbox-init";
         executing: "executing";
         "generating-metadata": "generating-metadata";
@@ -229,6 +228,7 @@ export declare const StepActivityPartSchema: z.ZodObject<{
         indexing: "indexing";
         persisting: "persisting";
         retrying: "retrying";
+        warning: "warning";
     }>;
     activity: z.ZodString;
 }, z.core.$strip>;
@@ -260,9 +260,9 @@ export declare const StepOutputFileSchema: z.ZodObject<{
     fileType: z.ZodEnum<{
         output: "output";
         summary: "summary";
-        log: "log";
-        figure: "figure";
         script: "script";
+        figure: "figure";
+        log: "log";
         notebook: "notebook";
     }>;
     description: z.ZodString;
@@ -279,9 +279,9 @@ export declare const StepOutputPartSchema: z.ZodObject<{
         fileType: z.ZodEnum<{
             output: "output";
             summary: "summary";
-            log: "log";
-            figure: "figure";
             script: "script";
+            figure: "figure";
+            log: "log";
             notebook: "notebook";
         }>;
         description: z.ZodString;
@@ -473,6 +473,18 @@ export declare const ReportRenderedPartSchema: z.ZodObject<{
     renderedAt: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const CompactionPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-compaction">;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        done: "done";
+        running: "running";
+    }>;
+    tokensBefore: z.ZodNumber;
+    tokensAfter: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"data-presentation">;
     id: z.ZodString;
@@ -592,7 +604,6 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     phase: z.ZodEnum<{
         failed: "failed";
         complete: "complete";
-        warning: "warning";
         "sandbox-init": "sandbox-init";
         executing: "executing";
         "generating-metadata": "generating-metadata";
@@ -600,6 +611,7 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         indexing: "indexing";
         persisting: "persisting";
         retrying: "retrying";
+        warning: "warning";
     }>;
     activity: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -627,9 +639,9 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         fileType: z.ZodEnum<{
             output: "output";
             summary: "summary";
-            log: "log";
-            figure: "figure";
             script: "script";
+            figure: "figure";
+            log: "log";
             notebook: "notebook";
         }>;
         description: z.ZodString;
@@ -765,4 +777,15 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     id: z.ZodString;
     renderedAt: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-compaction">;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        done: "done";
+        running: "running";
+    }>;
+    tokensBefore: z.ZodNumber;
+    tokensAfter: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>], "type">;

package/dist/contracts/schemas/chat-parts.js

@@ -299,6 +299,15 @@ export const ReportRenderedPartSchema = z.object({
     renderedAt: z.string(),
     title: z.string().optional(),
 });
+// ── Compaction ──────────────────────────────────────────────────────
+export const CompactionPartSchema = z.object({
+    type: z.literal("data-compaction"),
+    id: z.string(),
+    status: z.enum(["running", "done", "failed"]),
+    tokensBefore: z.number().int().nonnegative(),
+    tokensAfter: z.number().int().nonnegative().optional(),
+    durationMs: z.number().int().nonnegative().optional(),
+});
 // ── Union ───────────────────────────────────────────────────────────
 export const CortexChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
@@ -320,4 +329,5 @@ export const CortexChatPartSchema = z.discriminatedUnion("type", [
     RunFailedPartSchema,
     ChildSessionStartedPartSchema,
     ReportRenderedPartSchema,
+    CompactionPartSchema,
 ]);

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. */