@inflexa-ai/harness 0.46.2 → 0.48.0

package/dist/agents/sandbox/types.d.ts

@@ -12,7 +12,7 @@
  * in the tool's `perSource` report; the rest of the call still answers.
  */
 /** Closed allowlist of tools any sandbox agent may declare. */
-export type SandboxToolName = "listAvailablePackages" | "listAvailableRefs" | "scanInputs" | "resolveLibraryId" | "queryDocs" | "inspectRun" | "pubmed" | "resolve_citation" | "searchGene" | "lookupAnnotation" | "searchInteractions" | "chembl" | "pubchem" | "opentargets" | "geneDiseaseEvidence" | "drugGeneInteractions" | "genePreclinicalProfile" | "searchFaers" | "searchClinicalTrials" | "searchGeoDatasets" | "searchRegulatoryApprovals" | "targetSafety" | "comptox" | "knowledgeTemplate";
+export type SandboxToolName = "listAvailablePackages" | "listAvailableRefs" | "scanInputs" | "resolveLibraryId" | "queryDocs" | "pubmed" | "resolve_citation" | "searchGene" | "lookupAnnotation" | "searchInteractions" | "chembl" | "pubchem" | "opentargets" | "geneDiseaseEvidence" | "drugGeneInteractions" | "genePreclinicalProfile" | "searchFaers" | "searchClinicalTrials" | "searchGeoDatasets" | "searchRegulatoryApprovals" | "targetSafety" | "comptox" | "knowledgeTemplate";
 /**
  * The reference datasets that one capability of one agent cannot run without.
  *

package/dist/agents/sandbox-catalog.d.ts

@@ -12,6 +12,8 @@ export type PlannerAgentMeta = {
     readonly id: string;
     readonly capabilities: readonly string[];
     readonly suitableFor: readonly string[];
+    /** The public databases that the agent queries at run time, thus a step of the agent needs no staged copy of them. */
+    readonly liveSources: readonly string[];
 };
 /** The sandbox agents the planner may assign to analysis-plan steps. */
 export declare const PLANNABLE_AGENT_CATALOG: readonly PlannerAgentMeta[];

package/dist/agents/sandbox-catalog.js

@@ -8,6 +8,28 @@
  * `{{AGENT_CATALOG}}` placeholder.
  */
 import { SANDBOX_AGENT_META } from "./sandbox/index.js";
+/**
+ * The public database behind each lookup tool of a sandbox agent. A tool that reads the environment or the run, and
+ * not a public database, has no entry.
+ */
+const LIVE_SOURCES = {
+    pubmed: "PubMed",
+    searchGene: "Ensembl and NCBI Gene",
+    lookupAnnotation: "GO, KEGG, and Reactome annotation",
+    searchInteractions: "STRING",
+    chembl: "ChEMBL",
+    pubchem: "PubChem",
+    opentargets: "Open Targets",
+    geneDiseaseEvidence: "GWAS Catalog, DisGeNET, and ClinVar",
+    drugGeneInteractions: "DGIdb, DrugBank, and PharmGKB",
+    genePreclinicalProfile: "Bgee expression and IMPC knockouts",
+    searchFaers: "FAERS",
+    searchClinicalTrials: "ClinicalTrials.gov",
+    searchGeoDatasets: "GEO",
+    searchRegulatoryApprovals: "FDA and EMA approvals",
+    targetSafety: "a curated target safety panel",
+    comptox: "EPA CompTox",
+};
 /** The sandbox agents the planner may assign to analysis-plan steps. */
 export const PLANNABLE_AGENT_CATALOG = Object.values(SANDBOX_AGENT_META)
     .filter((meta) => meta.plannable !== false)
@@ -15,6 +37,10 @@ export const PLANNABLE_AGENT_CATALOG = Object.values(SANDBOX_AGENT_META)
     id: meta.id,
     capabilities: [...meta.capabilities],
     suitableFor: [...meta.suitableFor],
+    liveSources: meta.tools.flatMap((tool) => {
+        const source = LIVE_SOURCES[tool];
+        return source === undefined ? [] : [source];
+    }),
 }));
 /**
  * The reference datasets one capability of one agent cannot run without, by catalog id.
@@ -58,6 +84,9 @@ export const KNOWN_AGENT_IDS = Object.keys(SANDBOX_AGENT_META);
  */
 export function formatAgentCatalog(catalog = PLANNABLE_AGENT_CATALOG) {
     return catalog
-        .map((meta) => `- **${meta.id}**: capabilities: [${meta.capabilities.join(", ")}], ` + `suitable for: [${meta.suitableFor.join(", ")}]`)
+        .map((meta) => {
+        const live = meta.liveSources.length === 0 ? "" : `, live lookups: [${meta.liveSources.join(", ")}]`;
+        return `- **${meta.id}**: capabilities: [${meta.capabilities.join(", ")}], suitable for: [${meta.suitableFor.join(", ")}]${live}`;
+    })
         .join("\n");
 }

package/dist/app/synthesize-run.d.ts

@@ -14,6 +14,8 @@
  * honest non-fatal outcomes (no summaries, blocker) return empty findings after
  * a `skipped` phase.
  */
+import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
+import type { ScriptRuntime } from "../tools/script/run-script.js";
 import type { Querier } from "../state/db.js";
 import type { SynthesisPhase } from "@inflexa-ai/harness/contracts/chat-parts.js";
 import type { RunSession } from "../auth/types.js";
@@ -36,18 +38,21 @@ export type SynthesizeRunDeps = {
     readonly embedding: EmbeddingProvider;
     /** Embedder-supplied workspace-root resolution seam (see workspace/paths.ts). */
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    /** The read path of the workspace. The synthesizer reads the files of the run through it. */
+    readonly workspaceFs: WorkspaceFilesystem;
     /** Model id for the synthesizer agent loop. */
     readonly synthesisModel: string;
-    /** The `literature_reviewer` tool of the synthesizer. */
-    readonly literatureReviewer: Tool;
+    /** The lookup tools of the synthesizer (`createSynthesisLookupTools`). */
+    readonly synthesisLookups: readonly Tool[];
+    /** Where the VM of `run_script` comes from, for the lookups of the synthesizer. */
+    readonly scriptRuntime?: ScriptRuntime;
     /** LLM usage-accounting seam for the synthesizer loop; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
-    /** The store of the synthesizer and reviewer loops and of their read tools. */
+    /** The store of the synthesizer loop and of its read tool. */
     readonly toolOutputStore?: ToolOutputStore;
 };
 /** Optional fields for a progress update, mirroring the wire part. */
 export type SynthesisProgressExtra = {
-    readonly delegationCount?: number;
     readonly reason?: string;
     readonly error?: string;
 };
@@ -62,8 +67,7 @@ export type SynthesizeRunParams = {
     readonly onProgress: (phase: SynthesisPhase, activity: string, extra?: SynthesisProgressExtra) => void | Promise<void>;
     /**
      * Run a read or a write of the synthesis once: a step in the body of a workflow, a plain call in a process. The
-     * loop of the synthesizer runs outside it, thus each of its model calls is a step of its own, and each reviewer
-     * call starts a child workflow.
+     * loop of the synthesizer runs outside it, thus each of its model calls and each of its lookups is a step of its own.
      */
     readonly durably: <T>(name: string, run: () => Promise<T>) => Promise<T>;
     /** The pause of the run, for the loop of the synthesizer. Absent: a failed request fails the synthesis. */

package/dist/app/synthesize-run.js

@@ -25,7 +25,7 @@ import { loadPlan, queryRun } from "../state/index.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 export async function synthesizeRun(deps, params) {
-    const { pool, provider, embedding, resolveWorkspaceRoot, synthesisModel, literatureReviewer, usageRecorder } = deps;
+    const { pool, provider, embedding, resolveWorkspaceRoot, synthesisModel, synthesisLookups, usageRecorder } = deps;
     const { analysisId, runId, completedSteps, session, emit, onProgress, durably, pause } = params;
     await onProgress("starting", "Beginning literature-grounded synthesis");
     try {
@@ -47,9 +47,11 @@ export async function synthesizeRun(deps, params) {
             provider,
             session: synthesizerSession,
             model: synthesisModel,
-            literatureReviewer,
+            synthesisLookups,
+            scriptRuntime: deps.scriptRuntime,
             usageRecorder,
             toolOutputStore: deps.toolOutputStore,
+            workspace: { workspaceFs: deps.workspaceFs, pool, embedding, resolveWorkspaceRoot },
             summaries,
             planNarrative,
             runId,

package/dist/contracts/analogy-report.d.ts

@@ -16,8 +16,49 @@ export declare const AnalogyCoverageSchema: z.ZodEnum<{
     search_failed: "search_failed";
 }>;
 export type AnalogyCoverage = z.infer<typeof AnalogyCoverageSchema>;
+/** One analogy of a report, with the cited solutions of its target domain. */
+export declare const AnalogySchema: z.ZodObject<{
+    targetDomain: z.ZodString;
+    analogyTitle: z.ZodString;
+    objectMappings: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strip>>;
+    sharedRelations: z.ZodString;
+    coverage: z.ZodEnum<{
+        available: "available";
+        not_loaded: "not_loaded";
+        queried_no_data: "queried_no_data";
+        search_failed: "search_failed";
+    }>;
+    solutions: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        sourceDomain: z.ZodString;
+        description: z.ZodString;
+        keyConcepts: z.ZodArray<z.ZodString>;
+        relevance: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            url: z.ZodURL;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        githubRepos: z.ZodArray<z.ZodObject<{
+            url: z.ZodURL;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The extraction of the problem: what the analogies map from. */
+export declare const AnalogyProblemSchema: z.ZodObject<{
+    problemSummary: z.ZodString;
+    problemObjects: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodString;
+    }, z.core.$strip>>;
+    problemRelations: z.ZodArray<z.ZodString>;
+    keyTerms: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
 export declare const AnalogyReportSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<"1">;
     problemSummary: z.ZodString;
     problemObjects: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -25,6 +66,7 @@ export declare const AnalogyReportSchema: z.ZodObject<{
     }, z.core.$strip>>;
     problemRelations: z.ZodArray<z.ZodString>;
     keyTerms: z.ZodArray<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"1">;
     analogies: z.ZodArray<z.ZodObject<{
         targetDomain: z.ZodString;
         analogyTitle: z.ZodString;
@@ -67,7 +109,6 @@ export declare const AnalogyReportErrorSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const AnalogicalReasonerOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    schemaVersion: z.ZodLiteral<"1">;
     problemSummary: z.ZodString;
     problemObjects: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -75,6 +116,7 @@ export declare const AnalogicalReasonerOutputSchema: z.ZodUnion<readonly [z.ZodO
     }, z.core.$strip>>;
     problemRelations: z.ZodArray<z.ZodString>;
     keyTerms: z.ZodArray<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"1">;
     analogies: z.ZodArray<z.ZodObject<{
         targetDomain: z.ZodString;
         analogyTitle: z.ZodString;
@@ -115,6 +157,8 @@ export declare const AnalogicalReasonerOutputSchema: z.ZodUnion<readonly [z.ZodO
         message: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>]>;
+export type Analogy = z.infer<typeof AnalogySchema>;
+export type AnalogyProblem = z.infer<typeof AnalogyProblemSchema>;
 export type AnalogyReport = z.infer<typeof AnalogyReportSchema>;
 export type AnalogyReportError = z.infer<typeof AnalogyReportErrorSchema>;
 export type AnalogicalReasonerOutput = z.infer<typeof AnalogicalReasonerOutputSchema>;

package/dist/contracts/analogy-report.js

@@ -10,35 +10,41 @@
  */
 import { z } from "zod";
 export const AnalogyCoverageSchema = z.enum(["available", "queried_no_data", "search_failed", "not_loaded"]);
-export const AnalogyReportSchema = z.object({
-    schemaVersion: z.literal("1"),
+/** One analogy of a report, with the cited solutions of its target domain. */
+export const AnalogySchema = z.object({
+    targetDomain: z.string(),
+    analogyTitle: z.string(),
+    objectMappings: z.array(z.object({
+        source: z.string(),
+        target: z.string(),
+        rationale: z.string(),
+    })),
+    sharedRelations: z.string(),
+    coverage: AnalogyCoverageSchema,
+    solutions: z.array(z.object({
+        title: z.string(),
+        sourceDomain: z.string(),
+        description: z.string().describe("Two or three sentences: the technical essentials of the method."),
+        keyConcepts: z.array(z.string()),
+        relevance: z.string().describe("How the method transfers back to the source problem."),
+        sources: z.array(z.object({ url: z.url(), title: z.string().describe("The exact title as the search result gives it.") })),
+        githubRepos: z.array(z.object({
+            url: z.url(),
+            description: z.string().optional(),
+        })),
+    })),
+});
+/** The extraction of the problem: what the analogies map from. */
+export const AnalogyProblemSchema = z.object({
     problemSummary: z.string(),
     problemObjects: z.array(z.object({ name: z.string(), role: z.string() })),
     problemRelations: z.array(z.string()),
     keyTerms: z.array(z.string()),
-    analogies: z.array(z.object({
-        targetDomain: z.string(),
-        analogyTitle: z.string(),
-        objectMappings: z.array(z.object({
-            source: z.string(),
-            target: z.string(),
-            rationale: z.string(),
-        })),
-        sharedRelations: z.string(),
-        coverage: AnalogyCoverageSchema,
-        solutions: z.array(z.object({
-            title: z.string(),
-            sourceDomain: z.string(),
-            description: z.string(),
-            keyConcepts: z.array(z.string()),
-            relevance: z.string(),
-            sources: z.array(z.object({ url: z.url(), title: z.string() })),
-            githubRepos: z.array(z.object({
-                url: z.url(),
-                description: z.string().optional(),
-            })),
-        })),
-    })),
+});
+export const AnalogyReportSchema = z.object({
+    schemaVersion: z.literal("1"),
+    ...AnalogyProblemSchema.shape,
+    analogies: z.array(AnalogySchema),
 });
 export const AnalogyReportErrorSchema = z.object({
     schemaVersion: z.literal("1"),

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

@@ -23,13 +23,6 @@ export type PlanStep = {
     agent: string;
     question: string;
     depends_on: string[];
-    resources?: {
-        cpu: number;
-        memoryGb: number;
-        gpu?: {
-            count: number;
-        };
-    };
     maxSteps: number;
     track?: string;
     step_type?: string;
@@ -142,11 +135,9 @@ export type RunStartedPart = {
     planSummary: string;
     stepCount: number;
 };
-/** `"pending"` = waiting on dependencies; `"queued"` = dependencies satisfied,
- *  held until in-flight steps free machine-budget capacity; `"skipped"` =
- *  unreachable — an upstream dependency failed or blocked, so the step can
- *  never be dispatched. */
-export type StepStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+/** `"pending"` = waiting on dependencies; `"skipped"` = unreachable — an
+ *  upstream dependency failed or blocked, so the step can never be dispatched. */
+export type StepStatus = "pending" | "running" | "completed" | "failed" | "skipped";
 export type DagStepState = {
     id: string;
     name: string;
@@ -381,8 +372,6 @@ export type SynthesisProgressPart = {
     activity: string;
     /** ISO 8601 time of the emission. Absent in a stream that an older harness wrote. */
     at?: string;
-    /** Number of literature-reviewer delegations started so far. */
-    delegationCount?: number;
     /** Agent-provided reason — set when phase === "skipped". */
     reason?: string;
     /** Error message — set when phase === "failed". */

package/dist/contracts/report-reference.d.ts

@@ -376,7 +376,8 @@ export declare const ScalarReferenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject
  * artifact as a table. Two conditions give the second reason. The file type refuses a read of a cell, or
  * the bytes are unrecoverable.
  *
- * `extraction-unavailable` means that the value tier must use an extraction arm that is not wired.
+ * `extraction-unavailable` means that the host read cannot give the cells: the file is over the cap of the
+ * host read, a parse fault stopped it, or its extension names no tabular format. No other reader exists.
  */
 export declare const UnresolvedReasonSchema: z.ZodEnum<{
     "ambiguous-match": "ambiguous-match";

package/dist/contracts/report-reference.js

@@ -212,7 +212,8 @@ export const ScalarReferenceSchema = z.discriminatedUnion("kind", [ArtifactValue
  * artifact as a table. Two conditions give the second reason. The file type refuses a read of a cell, or
  * the bytes are unrecoverable.
  *
- * `extraction-unavailable` means that the value tier must use an extraction arm that is not wired.
+ * `extraction-unavailable` means that the host read cannot give the cells: the file is over the cap of the
+ * host read, a parse fault stopped it, or its extension names no tabular format. No other reader exists.
  */
 export const UnresolvedReasonSchema = z.enum([
     "artifact-missing",

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

@@ -8,13 +8,6 @@ export declare const PlanStepSchema: z.ZodObject<{
     agent: z.ZodString;
     question: z.ZodString;
     depends_on: z.ZodArray<z.ZodString>;
-    resources: z.ZodOptional<z.ZodObject<{
-        cpu: z.ZodNumber;
-        memoryGb: z.ZodNumber;
-        gpu: z.ZodOptional<z.ZodObject<{
-            count: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
     grounding: z.ZodOptional<z.ZodObject<{
         status: z.ZodString;
         snapshot: z.ZodString;
@@ -113,13 +106,6 @@ export declare const PlanPartSchema: z.ZodObject<{
         agent: z.ZodString;
         question: z.ZodString;
         depends_on: z.ZodArray<z.ZodString>;
-        resources: z.ZodOptional<z.ZodObject<{
-            cpu: z.ZodNumber;
-            memoryGb: z.ZodNumber;
-            gpu: z.ZodOptional<z.ZodObject<{
-                count: z.ZodNumber;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
         grounding: z.ZodOptional<z.ZodObject<{
             status: z.ZodString;
             snapshot: z.ZodString;
@@ -209,7 +195,6 @@ export declare const StepStatusSchema: z.ZodEnum<{
     completed: "completed";
     failed: "failed";
     pending: "pending";
-    queued: "queued";
     running: "running";
     skipped: "skipped";
 }>;
@@ -221,7 +206,6 @@ export declare const DagStepStateSchema: z.ZodObject<{
         completed: "completed";
         failed: "failed";
         pending: "pending";
-        queued: "queued";
         running: "running";
         skipped: "skipped";
     }>;
@@ -244,7 +228,6 @@ export declare const DagStatePartSchema: z.ZodObject<{
             completed: "completed";
             failed: "failed";
             pending: "pending";
-            queued: "queued";
             running: "running";
             skipped: "skipped";
         }>;
@@ -572,7 +555,6 @@ export declare const SynthesisProgressPartSchema: z.ZodObject<{
     }>;
     activity: z.ZodString;
     at: z.ZodOptional<z.ZodString>;
-    delegationCount: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -731,13 +713,6 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         agent: z.ZodString;
         question: z.ZodString;
         depends_on: z.ZodArray<z.ZodString>;
-        resources: z.ZodOptional<z.ZodObject<{
-            cpu: z.ZodNumber;
-            memoryGb: z.ZodNumber;
-            gpu: z.ZodOptional<z.ZodObject<{
-                count: z.ZodNumber;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
         grounding: z.ZodOptional<z.ZodObject<{
             status: z.ZodString;
             snapshot: z.ZodString;
@@ -817,7 +792,6 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             completed: "completed";
             failed: "failed";
             pending: "pending";
-            queued: "queued";
             running: "running";
             skipped: "skipped";
         }>;
@@ -1027,7 +1001,6 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     activity: z.ZodString;
     at: z.ZodOptional<z.ZodString>;
-    delegationCount: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{

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

@@ -11,7 +11,6 @@ export const PlanStepSchema = z.object({
     agent: z.string(),
     question: z.string(),
     depends_on: z.array(z.string()),
-    resources: z.object({ cpu: z.number(), memoryGb: z.number(), gpu: z.object({ count: z.number() }).optional() }).optional(),
     grounding: z
         .object({
         status: z.string(),
@@ -139,7 +138,7 @@ export const RunStartedPartSchema = z.object({
     stepCount: z.number(),
 });
 // ── DAG State ───────────────────────────────────────────────────────
-export const StepStatusSchema = z.enum(["pending", "queued", "running", "completed", "failed", "skipped"]);
+export const StepStatusSchema = z.enum(["pending", "running", "completed", "failed", "skipped"]);
 export const DagStepStateSchema = z
     .object({
     id: z.string(),
@@ -324,7 +323,6 @@ export const SynthesisProgressPartSchema = z.object({
     phase: SynthesisPhaseSchema,
     activity: z.string(),
     at: z.string().optional(),
-    delegationCount: z.number().int().nonnegative().optional(),
     reason: z.string().optional(),
     error: z.string().optional(),
 });

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

@@ -78,6 +78,8 @@ export type RunCancelerDeps = {
     /** The run end that the body recorded: `null` when it recorded none, a rejection when the read fails.
      * The value is unchecked engine data. Production default: `DBOSClient.getEvent` with a zero timeout. */
     readonly readRecordedRunEnd?: (runId: string) => Promise<unknown>;
+    /** End the sandbox leases of the canceled workflows now, thus their machines and commands stop at once. */
+    readonly releaseLeasesOf?: (workflowIds: readonly string[]) => Promise<void>;
 };
 export type RunCanceler = {
     /**

package/dist/execution/run-canceler.js

@@ -118,6 +118,15 @@ export function createRunCanceler(deps) {
             catch (err) {
                 logger.error("late-child cancel sweep failed", { runId, ...logger.errorFields(err) });
             }
+            // Before the pauses clear: a lease workflow that waits in a pause is ended through its pause row.
+            if (deps.releaseLeasesOf !== undefined) {
+                try {
+                    await deps.releaseLeasesOf([...new Set([workflowId, ...knownChildren, ...childIds(cutSteps ?? [])])]);
+                }
+                catch (err) {
+                    logger.error("the sandbox leases of the run did not end; each ends at its next owner check", { runId, ...logger.errorFields(err) });
+                }
+            }
             // The cancel ended each wait of a paused step, and no workflow of the run deletes its row again.
             const cleared = await clearPausesOfWork(pool, runId);
             if (cleared.isErr())

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

@@ -7,10 +7,12 @@
  *                            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).
+ *   - the lookups         — the gene, protein, annotation, interaction,
+ *                            PubMed, citation, drug-gene, and preclinical
+ *                            tools (`createSynthesisLookupTools`). Each lookup
+ *                            records the PMIDs of its result, and
+ *                            `submit_synthesis` refuses a PMID that no lookup
+ *                            of the run returned.
  *
  * 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
@@ -21,16 +23,19 @@
  * resolves with `{ kind: "failed" }`, the wrapper emits a synthesis-progress
  * `failed` part. We do not throw here for routine submitter rejections.
  */
+import type { ScriptRuntime } from "../tools/script/run-script.js";
 import { type RunSynthesis, type SynthesisDraft } from "../schemas/run-synthesis.js";
 import type { RunSynthesisPart } from "../contracts/chat-parts.js";
 import type { StepSummary } from "../schemas/step-summary.js";
 import { type LoopOptions, type LoopStep } from "../loop/run-loop.js";
 import type { ToolOutputStore } from "../loop/tool-output.js";
-import type { ChatDataPart, EmitFn } from "../loop/types.js";
+import type { AgentDefinition, ChatDataPart, EmitFn } from "../loop/types.js";
 import type { ChatProvider } from "../providers/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { RunSession } from "../auth/types.js";
 import { type Tool } from "../tools/define-tool.js";
+import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
+import { type ReadSurfaceDeps } from "../tools/workspace/read-surface.js";
 /**
  * The synthesizer's agent identity — the `source.agentId` on its loop events
  * and the `agent_id` of the run-phase `synthesis` row `executeAnalysis` writes
@@ -50,6 +55,14 @@ export type SubmitSynthesisOutput = {
     accepted: false;
     issues: ValidationIssue[];
 };
+/** Each PMID that a lookup result holds under a `pmid` or `pmids` key, outside the echo of the request. */
+export declare function pmidsIn(value: unknown, found?: Set<string>): Set<string>;
+/**
+ * A lookup whose ok result records the PMIDs that it holds. The loop folds the
+ * record into `seen` after each round, on the first run and on each replay, thus
+ * the check of `submit_synthesis` reads the same set in both.
+ */
+export declare function recordingPmids(tool: Tool, seen: Set<string>): Tool;
 /** The last accepted synthesis of a run, from the inputs of the calls of `submit_synthesis` that it accepted. */
 export declare function acceptedSynthesisOf(steps: readonly LoopStep[]): SynthesisDraft | undefined;
 /**
@@ -58,6 +71,7 @@ export declare function acceptedSynthesisOf(steps: readonly LoopStep[]): Synthes
  */
 export declare function __buildInnerToolsForTest(args: {
     knownStepIds: ReadonlySet<string>;
+    lookedUpPmids?: ReadonlySet<string>;
 }): {
     submit: Tool<{
         synthesis: SynthesisDraft;
@@ -70,12 +84,16 @@ export type GenerateRunSynthesisInput = {
     readonly provider: ChatProvider;
     readonly session: RunSession;
     readonly model: string;
-    /** The `literature_reviewer` tool of the synthesizer (`createLiteratureReviewerTool`). */
-    readonly literatureReviewer: Tool;
+    /** The lookup tools of the synthesizer (`createSynthesisLookupTools`). They run in `run_script`. */
+    readonly synthesisLookups: readonly Tool[];
+    /** Where the VM of `run_script` comes from. See {@link ScriptRuntime}. */
+    readonly scriptRuntime?: ScriptRuntime;
     /** LLM usage-accounting seam for the synthesizer loop; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
-    /** The store of the synthesizer and reviewer loops and of their read tools. */
+    /** The store of the synthesizer loop and of its read tool. */
     readonly toolOutputStore?: ToolOutputStore;
+    /** The read-only surface of the workspace. The synthesizer reads a file of the run where a summary is thin. */
+    readonly workspace: SynthesizerWorkspace;
     /** Step summaries from the completed run. Non-empty. */
     readonly summaries: readonly StepSummary[];
     /** Plan analytical narrative for context. */
@@ -89,6 +107,14 @@ export type GenerateRunSynthesisInput = {
     /** The pause of the run. The body of the run gives it, thus a failed request waits in place. */
     readonly pause?: LoopOptions["pause"];
 };
+/** The read-only workspace of the synthesizer: the file tools, the search, the data profile, and the script reads. */
+export type SynthesizerWorkspace = ReadSurfaceDeps & {
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+};
+/** What the synthesizer agent is built from, for a consumer that runs the agent outside `generateRunSynthesis`. */
+export type SynthesizerAgentInput = Pick<GenerateRunSynthesisInput, "model" | "synthesisLookups" | "scriptRuntime" | "toolOutputStore" | "summaries" | "workspace">;
+/** The synthesizer agent of one run. Its submit tool checks the step ids of the summaries and the PMIDs of its lookups. */
+export declare function synthesizerAgentOf(input: SynthesizerAgentInput): AgentDefinition;
 export type GenerateRunSynthesisResult = {
     kind: "synthesis";
     synthesis: RunSynthesis;
@@ -143,6 +169,8 @@ export declare function readSynthesisText(args: ReadSynthesisInput): Promise<str
  */
 export declare function readRunSynthesis(args: ReadSynthesisInput): Promise<RunSynthesisPart | null>;
 export declare function formatSynthesisEmbeddingText(synthesis: RunSynthesis): string;
+/** The first message of the synthesizer: the narrative of the plan and the summary of each step. */
+export declare function synthesizerSeedOf(planNarrative: string, summaries: readonly StepSummary[]): string;
 /**
  * Build the `data-run-synthesis` chat part the parent stream emits when the
  * synthesizer completes successfully. The schema mirrors the harness's contracts