@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/execution/run-synthesis.js

@@ -1,18 +1,16 @@
 /**
- * Run synthesizer — a single-shot agent loop driven through `runAgent`:
+ * Run synthesizer — a single-shot agent loop driven through `runWithSalvage`:
  *
- *   - `validate_synthesis` — non-terminal: dry-run schema + semantic validation
- *                            of a candidate in any shape. Never records.
- *   - `submit_synthesis`  — terminal: schema + semantic validation, captures
- *                            the outcome. Re-callable; a later valid submission
- *                            supersedes an earlier outcome (last-valid-wins).
- *   - `report_blocker`    — terminal: the run produced nothing synthesizable.
- *                            Only records when no outcome exists yet, so a
- *                            blocker can never clobber a real synthesis.
- *   - `literature_reviewer` — research sub-agent exposed as a tool. The tool
- *                            re-uses `createLiteratureReviewerTool`; the
- *                            sub-agent loop's brief is the only context handed
- *                            across the boundary (forSubAgent semantics).
+ *   - `submit_synthesis`  — checks one synthesis against the schema and the
+ *                            semantic checks, and gives back the issues. It
+ *                            does not end the run. The last accepted
+ *                            submission is the synthesis.
+ *   - `report_blocker`    — the run produced nothing synthesizable. An
+ *                            accepted synthesis wins over a blocker.
+ *   - `literature_reviewer` — research sub-agent exposed as a tool. The
+ *                            runtime registers it one time and gives it here;
+ *                            the sub-agent loop's brief is the only context
+ *                            handed across the boundary (forSubAgent semantics).
  *
  * Two deliverables on a happy path: `synthesis.json` written to the run dir
  * and a `data-run-synthesis` chat data part emitted via the `emit` callback
@@ -28,20 +26,18 @@ import { join } from "node:path";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { writeFileWithinRoot } from "../lib/fs-helpers.js";
+import { isAllDigits } from "../lib/text.js";
 import { tryFs } from "../lib/fs-result.js";
-import { hintForZodIssue } from "../lib/zod-issues.js";
-import { BiologicalThemeSchema, KeyReferenceSchema, RunSynthesisSchema, SynthesizedFindingSchema, } from "../schemas/run-synthesis.js";
+import { safeParseJsonAs } from "../lib/parse-json.js";
+import { RunSynthesisSchema, SynthesisDraftSchema, } from "../schemas/run-synthesis.js";
 import { synthesisAgentPrompt } from "../prompts/synthesis-agent.js";
 import { composeSystemPrompt } from "../agents/system-prompt.js";
-import { flattenDataPart } from "../contracts/chat-frame.js";
 import { isSafeId, runDir } from "../workspace/paths.js";
-import { decodeObjectString } from "../lib/zod-issues.js";
-import { runToTerminal } from "../loop/run-to-terminal.js";
-import { passthroughStep } from "../loop/run-step.js";
+import { runWithSalvage } from "../loop/run-loop.js";
+import { recordedInputOf } from "../loop/tool-adapter.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";
+import { blockerOf, createReportBlockerToolFor, REPORT_BLOCKER_TOOL_ID } from "../tools/sandbox/report-blocker.js";
 // ── Agent identity / budgets ────────────────────────────────────────
 /**
  * The synthesizer's agent identity — the `source.agentId` on its loop events
@@ -60,35 +56,15 @@ const SYNTHESIZER_MAX_ITERATIONS = 25;
  * model treats a stated call-count limit as a target to hit, not a maximum.
  */
 const LITERATURE_REVIEWER_BUDGET = 3;
+const SubmitSynthesisOutputSchema = z.object({ accepted: z.boolean() });
+const SUBMIT_SYNTHESIS_TOOL_ID = "submit_synthesis";
 // ── Validation ──────────────────────────────────────────────────────
-function zodIssuesToValidationIssues(error, input, rootPath = "synthesis") {
-    return error.issues.map((i) => ({
-        path: [rootPath, ...i.path.map((p) => String(p))].join("."),
-        code: "schema",
-        message: i.message,
-        hint: hintForZodIssue(i, input),
-    }));
-}
-const PMID_PATTERN = /^\d+$/;
 // ── Semantic checks ─────────────────────────────────────────────────
 //
-// Each check takes only the fields it reads, never the whole synthesis. That is
-// what lets a candidate which failed whole-payload schema validation still be
-// checked: whichever fields parsed on their own get their checks run, and only
-// the checks whose inputs are genuinely missing are deferred. `semanticCheck`
-// composes them for the schema-valid path — it is the one definition of "all
-// semantic checks, in report order".
-function checkRunId(runId, ctx) {
-    if (runId === ctx.runId)
-        return [];
-    return [
-        {
-            path: "synthesis.runId",
-            code: "semantic",
-            message: `runId must be "${ctx.runId}"`,
-        },
-    ];
-}
+// Each check takes only the fields it reads, never the whole synthesis.
+// `semanticCheck` composes them — it is the one definition of "all semantic
+// checks, in report order". The input schema of the tool checks the shape
+// before them.
 function checkFindingStepIds(findings, ctx) {
     const issues = [];
     for (const [i, f] of findings.entries()) {
@@ -138,7 +114,7 @@ function checkFindingPmidFormat(findings) {
     const issues = [];
     for (const [fi, f] of findings.entries()) {
         for (const [ri, r] of f.references.entries()) {
-            if (!PMID_PATTERN.test(r.pmid)) {
+            if (r.pmid.length === 0 || !isAllDigits(r.pmid)) {
                 issues.push({
                     path: `synthesis.findings[${fi}].references[${ri}].pmid`,
                     code: "semantic",
@@ -152,7 +128,7 @@ function checkFindingPmidFormat(findings) {
 function checkKeyReferencePmidFormat(keyReferences) {
     const issues = [];
     for (const [i, r] of keyReferences.entries()) {
-        if (!PMID_PATTERN.test(r.pmid)) {
+        if (r.pmid.length === 0 || !isAllDigits(r.pmid)) {
             issues.push({
                 path: `synthesis.keyReferences[${i}].pmid`,
                 code: "semantic",
@@ -164,7 +140,6 @@ function checkKeyReferencePmidFormat(keyReferences) {
 }
 function semanticCheck(synthesis, ctx) {
     return [
-        ...checkRunId(synthesis.runId, ctx),
         ...checkFindingStepIds(synthesis.findings, ctx),
         ...checkThemeReferences(synthesis.themes, synthesis.findings),
         ...checkKeyReferencesCited(synthesis.keyReferences, synthesis.findings),
@@ -172,157 +147,42 @@ function semanticCheck(synthesis, ctx) {
         ...checkKeyReferencePmidFormat(synthesis.keyReferences),
     ];
 }
-function salvageInputs(candidate) {
-    const record = typeof candidate === "object" && candidate !== null ? candidate : {};
-    const runId = z.string().safeParse(record.runId);
-    const findings = z.array(SynthesizedFindingSchema).safeParse(record.findings);
-    const themes = z.array(BiologicalThemeSchema).safeParse(record.themes);
-    const keyReferences = z.array(KeyReferenceSchema).safeParse(record.keyReferences);
-    return {
-        runId: runId.success ? runId.data : undefined,
-        findings: findings.success ? findings.data : undefined,
-        themes: themes.success ? themes.data : undefined,
-        keyReferences: keyReferences.success ? keyReferences.data : undefined,
-    };
-}
-/**
- * A short issue list must never read as "everything else is fine". When the
- * payload failed schema validation and some checks could not run, the deferred
- * ones are named back to the model as an issue of their own.
- */
-function deferredChecksNotice(deferred) {
-    return {
-        path: "synthesis",
-        code: "semantic",
-        message: `This issue list is INCOMPLETE: ${deferred.length} semantic check(s) could not run because the fields ` +
-            `they read did not survive schema validation — ${deferred.join("; ")}.`,
-        hint: "Fix the schema issues above and call validate_synthesis again; the deferred checks will run then and may report further problems.",
-    };
-}
-/**
- * Semantic checks over a candidate that failed `RunSynthesisSchema`. Every check
- * whose own inputs parsed is run; the rest are reported as deferred.
- */
-function salvagedSemanticCheck(candidate, ctx) {
-    const { runId, findings, themes, keyReferences } = salvageInputs(candidate);
-    const issues = [];
-    const deferred = [];
-    if (runId !== undefined)
-        issues.push(...checkRunId(runId, ctx));
-    else
-        deferred.push("runId matches the run");
-    if (findings !== undefined)
-        issues.push(...checkFindingStepIds(findings, ctx));
-    else
-        deferred.push("finding stepIds are present in the input summaries");
-    if (themes !== undefined && findings !== undefined)
-        issues.push(...checkThemeReferences(themes, findings));
-    else
-        deferred.push("theme references resolve to entries in findings[]");
-    if (keyReferences !== undefined && findings !== undefined)
-        issues.push(...checkKeyReferencesCited(keyReferences, findings));
-    else
-        deferred.push("keyReferences PMIDs are cited by some finding");
-    if (findings !== undefined)
-        issues.push(...checkFindingPmidFormat(findings));
-    else
-        deferred.push("finding reference PMIDs are numeric");
-    if (keyReferences !== undefined)
-        issues.push(...checkKeyReferencePmidFormat(keyReferences));
-    else
-        deferred.push("keyReferences PMIDs are numeric");
-    if (deferred.length > 0)
-        issues.push(deferredChecksNotice(deferred));
-    return issues;
-}
-/**
- * Validate a candidate in one pass. A schema failure no longer hides the
- * semantic problems behind it: structure issues come first, then every semantic
- * check whose inputs survived, then an explicit note of what was deferred.
- */
-function fullyValidate(candidate, ctx) {
-    const parsed = RunSynthesisSchema.safeParse(candidate);
-    if (!parsed.success) {
-        return {
-            valid: false,
-            issues: [...zodIssuesToValidationIssues(parsed.error, candidate), ...salvagedSemanticCheck(candidate, ctx)],
-        };
-    }
-    const semanticIssues = semanticCheck(parsed.data, ctx);
-    if (semanticIssues.length > 0) {
-        return { valid: false, issues: semanticIssues };
-    }
-    return { valid: true, synthesis: parsed.data };
-}
 // ── Inner tools ─────────────────────────────────────────────────────
-function buildValidateTool(ctx) {
+function buildSubmitTool(ctx) {
     return defineTool({
-        id: "validate_synthesis",
-        description: "Dry-run a candidate synthesis and get back everything that is wrong " +
-            "with it. Takes the synthesis in ANY shape: a malformed, partial, or " +
-            "wrong-typed candidate is REPORTED, not rejected. Returns " +
-            "{valid, issues[]} covering both schema problems (missing / " +
-            "wrong-typed fields) and the semantic checks a schema cannot express " +
-            "(unknown stepId refs, theme→finding refs, keyReferences PMIDs not " +
-            "cited by any finding, non-numeric PMIDs) in a SINGLE pass — a " +
-            "schema problem does not hide the semantic problems behind it. If a " +
-            "field is too malformed for a semantic check to read, that check is " +
-            "reported as deferred rather than silently skipped. The authoritative " +
-            "field-by-field synthesis schema is the arg schema of " +
-            "submit_synthesis — this tool deliberately does not restate it. " +
-            "Non-terminal: call as often as needed to iterate toward a clean " +
-            "synthesis, then submit_synthesis. A candidate that arrives as a " +
-            "JSON-encoded string is decoded before the checks run, so the " +
-            "result describes the synthesis inside the string.",
-        // Deliberately permissive: a structurally-invalid candidate must reach
-        // `execute` so the model gets a structured {valid:false, issues} result —
-        // including semantic issues — instead of a bare Zod rejection at the loop's
-        // input boundary. `execute` re-parses against RunSynthesisSchema itself.
-        // The permissive schema also means the loop's string repair never runs
-        // here, so `execute` decodes a JSON-encoded string itself.
-        inputSchema: z.object({
-            synthesis: z.unknown().describe("The candidate synthesis, in any shape. Field-by-field schema: see submit_synthesis."),
-        }),
+        id: SUBMIT_SYNTHESIS_TOOL_ID,
+        description: "Submit the synthesis. Checks the payload against the semantic checks " +
+            "the arg schema cannot express (stepId refs, theme→finding refs, " +
+            "keyReferences PMIDs cited, numeric PMIDs). On success returns " +
+            "{accepted: true} — STOP after this. On rejection returns " +
+            "{accepted: false, issues} — fix the specific fields at each issue " +
+            "path and call again, or switch to report_blocker if the synthesis " +
+            "cannot be made valid. The last accepted submission is the synthesis.",
+        inputSchema: z.object({ synthesis: SynthesisDraftSchema }),
         describeCall: "none",
-        execute: async (input) => {
-            const result = fullyValidate(decodeObjectString(input.synthesis), ctx);
-            return ok(result.valid ? { valid: true, issues: [] } : { valid: false, issues: result.issues });
+        execute: (input) => {
+            const issues = semanticCheck(input.synthesis, ctx);
+            return Promise.resolve(ok(issues.length > 0 ? { accepted: false, issues } : { accepted: true }));
         },
     });
 }
-function buildSubmitTool(holder, ctx) {
-    return defineTool({
-        id: "submit_synthesis",
-        description: "Submit the final synthesis. Re-validates the payload against the " +
-            "semantic checks the arg schema cannot express (stepId refs, " +
-            "theme→finding refs, keyReferences PMIDs cited, numeric PMIDs). On " +
-            "success returns {accepted: true} — STOP after this. On rejection " +
-            "returns {accepted: false, issues} — fix the specific fields at each " +
-            "issue path and call again, or switch to report_blocker if the " +
-            "synthesis cannot be made valid. A rejected submission leaves any " +
-            "already-accepted synthesis untouched; a later accepted submission " +
-            "supersedes an earlier one.",
-        inputSchema: z.object({ synthesis: RunSynthesisSchema }),
-        describeCall: "none",
-        execute: async (input) => {
-            const result = fullyValidate(input.synthesis, ctx);
-            if (!result.valid) {
-                // A rejection is not terminal — submission is last-valid-wins, so this
-                // leaves any already-recorded outcome intact and the model may fix the
-                // cited paths and submit again.
-                return ok({ accepted: false, issues: result.issues });
-            }
-            holder.outcome = { kind: "submitted", synthesis: result.synthesis };
-            return ok({ accepted: true });
-        },
-    });
+/** The last accepted synthesis of a run, from the inputs of the calls of `submit_synthesis` that it accepted. */
+export function acceptedSynthesisOf(steps) {
+    let accepted;
+    for (const step of steps) {
+        for (const call of step.calls) {
+            if (call.toolName !== SUBMIT_SYNTHESIS_TOOL_ID || call.output?.outcome !== "ok")
+                continue;
+            const outcome = SubmitSynthesisOutputSchema.safeParse(call.output.value);
+            const input = recordedInputOf(z.object({ synthesis: SynthesisDraftSchema }), call.input);
+            if (outcome.success && outcome.data.accepted && input !== undefined)
+                accepted = input.synthesis;
+        }
+    }
+    return accepted;
 }
-function buildBlockerTool(holder) {
+function buildBlockerTool() {
     return createReportBlockerToolFor({
-        record: (outcome) => {
-            if (holder.outcome === null)
-                holder.outcome = outcome;
-        },
         blockedWhen: "Ends run synthesis with no synthesis written. Use it ONLY when the " +
             "run produced no synthesizable content — every step summary is empty, " +
             "or the summaries are contradictory to the point of incoherence. A run " +
@@ -333,46 +193,28 @@ function buildBlockerTool(holder) {
 }
 /**
  * Test-only — expose the inner-tool factory so unit tests can assert on
- * validation + outcome capture without driving the whole agent loop.
+ * the checks without driving the whole agent loop.
  */
 export function __buildInnerToolsForTest(args) {
-    const holder = { outcome: null };
-    const ctx = {
-        knownStepIds: args.knownStepIds,
-        runId: args.runId,
-    };
-    return {
-        validate: buildValidateTool(ctx),
-        submit: buildSubmitTool(holder, ctx),
-        blocker: buildBlockerTool(holder),
-        holder,
-    };
+    const ctx = { knownStepIds: args.knownStepIds };
+    return { submit: buildSubmitTool(ctx), blocker: buildBlockerTool() };
 }
 /**
- * Drive the synthesizer agent loop to a terminal outcome — either a
- * validated synthesis (`submit_synthesis`) or a blocker (`report_blocker`).
- * Throws when neither terminal is reached (loop cap or external abort).
+ * Drive the synthesizer agent loop to an outcome — the last accepted
+ * synthesis (`submit_synthesis`), else a blocker (`report_blocker`).
+ * Throws when the run and its salvage end with neither (loop cap or external abort).
  */
 export async function generateRunSynthesis(input) {
     if (input.summaries.length === 0) {
         throw new Error("Run synthesis: no step summaries to synthesize");
     }
     const knownStepIds = new Set(input.summaries.map((s) => s.stepId));
-    const holder = { outcome: null };
-    const innerCtx = { knownStepIds, runId: input.runId };
-    const reviewer = createLiteratureReviewerTool({
-        provider: input.provider,
-        model: input.model,
-        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 innerCtx = { knownStepIds };
+    const reviewer = input.literatureReviewer;
+    const submitTool = buildSubmitTool(innerCtx);
+    const blockerTool = buildBlockerTool();
     const readTools = input.toolOutputStore ? [createReadToolOutputTool(input.toolOutputStore)] : [];
-    const tools = [validateTool, submitTool, blockerTool, reviewer, ...readTools];
+    const tools = [submitTool, blockerTool, reviewer, ...readTools];
     const agent = {
         id: SYNTHESIS_AGENT_ID,
         systemPrompt: composeSystemPrompt(synthesisAgentPrompt),
@@ -380,31 +222,32 @@ export async function generateRunSynthesis(input) {
         tools,
         maxIterations: SYNTHESIZER_MAX_ITERATIONS,
     };
-    const prompt = buildSynthesizerPrompt(input.planNarrative, input.summaries, input.runId);
+    const prompt = buildSynthesizerPrompt(input.planNarrative, input.summaries);
     const signal = input.signal ?? new AbortController().signal;
     const emit = input.emit ?? (() => { });
-    const loopDeps = {
+    const run = await runWithSalvage(agent, [{ role: "user", content: prompt }], input.session, {
         provider: input.provider,
         signal,
         emit,
-        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],
-        nudge: "You ended without calling a terminal tool. You MUST call " +
+        policy: { budget: { [reviewer.id]: LITERATURE_REVIEWER_BUDGET } },
+        pause: input.pause,
+    }, {
+        tools: [SUBMIT_SYNTHESIS_TOOL_ID, REPORT_BLOCKER_TOOL_ID],
+        nudge: "You ended without an accepted synthesis. You MUST call " +
             "submit_synthesis with the final synthesis now, or report_blocker " +
             "if the run produced nothing synthesizable. Do not reply with prose.",
+        hasOutcome: (steps) => acceptedSynthesisOf(steps) !== undefined || blockerOf(steps) !== null,
     });
-    const outcome = holder.outcome;
-    if (outcome?.kind === "submitted") {
-        return { kind: "synthesis", synthesis: outcome.synthesis };
+    const accepted = acceptedSynthesisOf(run.steps);
+    if (accepted !== undefined) {
+        // The model never types the run id: the host stamps the id of its own run.
+        return { kind: "synthesis", synthesis: { runId: input.runId, ...accepted } };
     }
-    if (outcome?.kind === "blocker") {
-        return { kind: "skipped", reason: outcome.reason };
+    const blocker = blockerOf(run.steps);
+    if (blocker !== null) {
+        return { kind: "skipped", reason: blocker.reason };
     }
     if (signal.aborted) {
         throw new Error("Run synthesis was cancelled.");
@@ -503,20 +346,17 @@ export async function readRunSynthesis(args) {
     if (text === undefined) {
         return null;
     }
-    let json;
+    let parsed;
     try {
-        json = JSON.parse(text);
+        parsed = safeParseJsonAs(text, RunSynthesisSchema);
     }
     catch {
         return null;
     }
-    const parsed = RunSynthesisSchema.safeParse(json);
     if (!parsed.success) {
         return null;
     }
-    // The payload comes from a validated `RunSynthesis`, and the builder sets each field of the part contract.
-    // The tests parse the result with `RunSynthesisPartSchema`.
-    return flattenDataPart(buildRunSynthesisPart(args.runId, parsed.data));
+    return { type: "data-run-synthesis", ...runSynthesisPartFields(args.runId, parsed.data) };
 }
 // ── Embedding text ──────────────────────────────────────────────────
 export function formatSynthesisEmbeddingText(synthesis) {
@@ -545,9 +385,9 @@ export function formatSynthesisEmbeddingText(synthesis) {
     ].join("\n");
 }
 // ── Prompt builder ──────────────────────────────────────────────────
-function buildSynthesizerPrompt(planNarrative, summaries, runId) {
+function buildSynthesizerPrompt(planNarrative, summaries) {
     const summaryBlock = summaries.map((s) => `### ${s.stepId} (${s.agentId})\n\n${s.markdown}`).join("\n\n---\n\n");
-    return [`runId: "${runId}"`, "", "## Analytical Narrative", planNarrative, "", "## Step Summaries", summaryBlock].join("\n");
+    return ["## Analytical Narrative", planNarrative, "", "## Step Summaries", summaryBlock].join("\n");
 }
 // ── Chat data part builders ─────────────────────────────────────────
 /**
@@ -556,17 +396,18 @@ function buildSynthesizerPrompt(planNarrative, summaries, runId) {
  * `RunSynthesisPart` interface — keep them in lockstep.
  */
 export function buildRunSynthesisPart(runId, synthesis) {
+    return { type: "data-run-synthesis", data: runSynthesisPartFields(runId, synthesis) };
+}
+/** The flat fields of the `data-run-synthesis` part, shared by the stream part and the stored-record read. */
+function runSynthesisPartFields(runId, synthesis) {
     return {
-        type: "data-run-synthesis",
-        data: {
-            id: `synthesis-${runId}`,
-            runId,
-            overview: synthesis.overview,
-            conclusions: synthesis.conclusions,
-            findings: synthesis.findings,
-            themes: synthesis.themes,
-            limitations: synthesis.limitations,
-            keyReferences: synthesis.keyReferences,
-        },
+        id: `synthesis-${runId}`,
+        runId,
+        overview: synthesis.overview,
+        conclusions: synthesis.conclusions,
+        findings: synthesis.findings,
+        themes: synthesis.themes,
+        limitations: synthesis.limitations,
+        keyReferences: synthesis.keyReferences,
     };
 }

package/dist/execution/staged-input.d.ts

@@ -18,7 +18,7 @@
  * service derives from its object-store index and the CLI synthesizes from the
  * local path — the harness treats them as opaque labels.
  */
-export interface StagedInput {
+export type StagedInput = {
     readonly fileId: string;
     readonly mountName: string;
     readonly key: string;
@@ -38,4 +38,4 @@ export interface StagedInput {
     readonly mtimeMs: number;
     /** Path relative to the data dir, e.g. "inputs/{mountName}/{key}". */
     readonly relativePath: string;
-}
+};

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

@@ -1,6 +1,6 @@
 /**
  * Per-step interpretive summary. Continues the step agent's conversation
- * (`continueAgent`) so the request reuses the cached prefix and keeps
+ * (`continueLoop`) so the request reuses the cached prefix and keeps
  * signed thinking blocks valid.
  *
  * Contract:
@@ -9,7 +9,7 @@
  *     summary as its final assistant text.
  *   - Returns `{ stepId, agentId, markdown }` on non-empty final text;
  *     `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.
+ *     before a final answer. Non-fatal.
  *   - `Session` is taken explicitly (see the harness-durable-runtime spec).
  *
  * Honest empty: with no output artifacts the request directs the model to
@@ -24,11 +24,11 @@
 import type { AgentSession } from "../auth/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 { ChatProvider } from "../providers/types.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 {
+export type GenerateStepSummaryOptions = {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
     /** LLM usage-accounting seam for the continuation; omitted falls back to the no-op recorder. */
@@ -36,7 +36,7 @@ export interface GenerateStepSummaryOptions {
     /** 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 provider: ChatProvider;
     readonly session: AgentSession;
     /** The step agent: the continuation sends its system prompt and its declared tools. */
     readonly agent: AgentDefinition;
@@ -47,6 +47,6 @@ export interface GenerateStepSummaryOptions {
     readonly agentId: string;
     readonly runId: string;
     readonly signal?: AbortSignal;
-}
+};
 /** Returns `undefined` on non-fatal failure instead of throwing. */
 export declare function generateStepSummary(opts: GenerateStepSummaryOptions): Promise<StepSummary | undefined>;

package/dist/execution/step-summary.js

@@ -1,6 +1,6 @@
 /**
  * Per-step interpretive summary. Continues the step agent's conversation
- * (`continueAgent`) so the request reuses the cached prefix and keeps
+ * (`continueLoop`) so the request reuses the cached prefix and keeps
  * signed thinking blocks valid.
  *
  * Contract:
@@ -9,7 +9,7 @@
  *     summary as its final assistant text.
  *   - Returns `{ stepId, agentId, markdown }` on non-empty final text;
  *     `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.
+ *     before a final answer. Non-fatal.
  *   - `Session` is taken explicitly (see the harness-durable-runtime spec).
  *
  * Honest empty: with no output artifacts the request directs the model to
@@ -21,9 +21,7 @@
  * 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 { continueAgent } from "../loop/continue-agent.js";
-import { finalText } from "../loop/run-agent.js";
-import { passthroughStep } from "../loop/run-step.js";
+import { continueLoop, finalText } from "../loop/run-loop.js";
 import { READ_TOOL_OUTPUT_TOOL_ID } from "../loop/tool-output.js";
 import { stepSummaryPrompt } from "../prompts/execute-analysis/step-summary.js";
 import { StepSummarySchema } from "../schemas/step-summary.js";
@@ -49,17 +47,15 @@ export async function generateStepSummary(opts) {
     const logger = (opts.logger ?? createNoopLogger()).named("step-summary").with({ runId: opts.runId, stepId: opts.stepId, agentId: opts.agentId });
     let result;
     try {
-        result = await continueAgent(opts.agent, opts.conversation, {
+        result = await continueLoop(opts.agent, opts.conversation, {
             text: summaryRequest(opts.artifactPaths),
             mask: { allow: SUMMARY_TOOLS },
             maxRequests: SUMMARY_MAX_REQUESTS,
-            stepNamespace: "step-summary",
             accountingAgentId: SUMMARY_AGENT_ID,
         }, opts.session, {
             provider: opts.provider,
             signal: opts.signal ?? new AbortController().signal,
             emit: () => { },
-            runStep: passthroughStep,
             usageRecorder: opts.usageRecorder,
             toolOutputStore: opts.toolOutputStore,
         });

package/dist/execution/topo-sort.js

@@ -4,6 +4,7 @@
  * Uses Kahn's algorithm to group steps into waves where steps within
  * a wave have no inter-dependencies and can run in parallel.
  */
+import { presentGet } from "../lib/present.js";
 // ── Errors ─────────────────────────────────────────────────────────
 /** Thrown when the plan DAG contains a dependency cycle. */
 export class CycleError extends Error {
@@ -64,7 +65,7 @@ export function topoSortIntoWaves(steps) {
     for (const step of steps) {
         for (const dep of step.depends_on) {
             inDegree.set(step.id, (inDegree.get(step.id) ?? 0) + 1);
-            dependents.get(dep).push(step.id);
+            presentGet(dependents, dep, "the dependents list of the dependency").push(step.id);
         }
     }
     // Process wave by wave: each wave consists of all nodes with in-degree 0
@@ -74,13 +75,13 @@ export function topoSortIntoWaves(steps) {
     let frontier = steps.filter((s) => inDegree.get(s.id) === 0).map((s) => s.id);
     while (frontier.length > 0) {
         // Current frontier forms a wave
-        const wave = frontier.map((id) => stepById.get(id));
+        const wave = frontier.map((id) => presentGet(stepById, id, "the step of the frontier id"));
         waves.push(wave);
         remaining -= frontier.length;
         // Compute next frontier
         const nextFrontier = [];
         for (const id of frontier) {
-            for (const dep of dependents.get(id)) {
+            for (const dep of presentGet(dependents, id, "the dependents list of the wave id")) {
                 const newDeg = (inDegree.get(dep) ?? 1) - 1;
                 inDegree.set(dep, newDeg);
                 if (newDeg === 0) {

package/dist/execution/workflow-purger.d.ts

@@ -23,7 +23,7 @@
  */
 import type { ResultAsync } from "neverthrow";
 import type { DbError } from "../lib/db-result.js";
-export interface WorkflowPurger {
+export type WorkflowPurger = {
     /** Workflow ids in a given id namespace (e.g. `dataprofile:{analysisId}:`). Empty when the ledger has no schema yet. */
     findByIdPrefix(prefix: string): ResultAsync<string[], DbError>;
     /** Cancel the given workflows so no executor keeps writing behind a purge. Unknown ids are ignored. */
@@ -35,4 +35,4 @@ export interface WorkflowPurger {
      * reports no count of its own.
      */
     deleteWorkflows(workflowIds: readonly string[], includeDescendants?: boolean): ResultAsync<number, DbError>;
-}
+};