@inflexa-ai/harness 0.45.0 → 0.45.1

package/dist/agents/conversation-agent.d.ts

@@ -37,6 +37,7 @@ import type { ExtendAnalysisFarm } from "../sandbox/types.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type BioToolKeys } from "../tools/bio/keys.js";
+import type { KnowledgeClient } from "../tools/knowledge/index.js";
 import type { EnvironmentStorePaths } from "../config/environment-stores.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { RunLauncher } from "../execution/run-launcher.js";
@@ -44,6 +45,7 @@ import type { ProvenanceSeam } from "../provenance/seam.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { CitationResolver } from "../citations/types.js";
+import { type WebSearchEngine } from "../tools/research/web-search.js";
 /** Canonical agent id — the single source of truth. */
 export declare const CONVERSATION_AGENT_ID: "conversation-agent";
 /**
@@ -63,6 +65,8 @@ export interface ConversationAgentDeps extends EnvironmentStorePaths {
     readonly usageRecorder?: UsageRecorder;
     /** Adds `read_tool_output`, and each loop-driving tool gives the same store to its sub-agent. */
     readonly toolOutputStore?: ToolOutputStore;
+    /** The web-search engine the embedder injected; set, `web_search` attaches, absent it does not. `web_fetch` attaches either way. */
+    readonly webSearch?: WebSearchEngine;
     /** Shared host-side bibliographic verification service. */
     readonly citationResolver: CitationResolver;
     /** The LLM seam every loop-driving tool runs its sub-agent on. */
@@ -107,6 +111,12 @@ export interface ConversationAgentDeps extends EnvironmentStorePaths {
     readonly runLauncher: RunLauncher;
     /** API keys for the external bio/chem data sources. */
     readonly bioKeys: BioToolKeys;
+    /**
+     * The knowledge service client, for the planner that `generate_plan` drives.
+     * Absent, the planner attaches no knowledge tool. The conversation agent
+     * itself gets `knowledge_recommend` through `hostTools`, from the embedder.
+     */
+    readonly knowledge?: KnowledgeClient;
     /** Skills root. No tool of the roster reads it. */
     readonly skillsDir: string;
     /** Headless-Chrome config for report snapshot/preview rendering. */

package/dist/agents/conversation-agent.js

@@ -36,10 +36,13 @@ import { createEditFileTool, createFileStatTool, createGrepTool, createListFiles
 import { showUserTool } from "../tools/display/index.js";
 import { createUpdateWorkingMemoryTool } from "../tools/memory/index.js";
 import { createListAvailablePackagesTool } from "../tools/sandbox/list-available-packages.js";
+import { createInspectCapabilityDataTool } from "../tools/capability-data.js";
 import { createListAvailableRefsTool } from "../tools/sandbox/list-available-refs.js";
 import { createExecuteAnalysisTool } from "../tools/execute-analysis.js";
 import { createStartReportSessionTool } from "../tools/start-report-session.js";
 import { createResolveCitationTool } from "../tools/research/resolve-citation.js";
+import { createWebFetchTool } from "../tools/research/web-fetch.js";
+import { createWebSearchTool } from "../tools/research/web-search.js";
 /** Canonical agent id — the single source of truth. */
 export const CONVERSATION_AGENT_ID = "conversation-agent";
 /** Runaway guard — heavy tool-driving turns need generous headroom. */
@@ -48,7 +51,7 @@ const CONVERSATION_MAX_ITERATIONS = 200;
 const CONVERSATION_COMPACTION = { turnStartBudget: 150_000, budget: 200_000 };
 /** Build the conversation `AgentDefinition` with every tool fully dep-bound. */
 export function createConversationAgent(deps) {
-    const { provider, pool, embedding, workspaceFs, model, utilityProvider, utilityModel, executeAnalysisWorkflow, runAuthorizer, runLauncher, bioKeys, chrome, resourcePolicy, hostTools, refStorePath, farmLockFile, imagePackagesFile, readPoolInventory, usageRecorder, toolOutputStore, citationResolver, } = deps;
+    const { provider, pool, embedding, workspaceFs, model, utilityProvider, utilityModel, executeAnalysisWorkflow, runAuthorizer, runLauncher, bioKeys, chrome, resourcePolicy, hostTools, refStorePath, farmLockFile, imagePackagesFile, readPoolInventory, usageRecorder, toolOutputStore, citationResolver, webSearch, } = deps;
     const workingMemory = createWorkingMemory(pool);
     const ncbi = createNcbiTools(bioKeys);
     const chemDb = createChemDbTools(bioKeys, { ...(deps.logger ? { logger: deps.logger } : {}) });
@@ -81,6 +84,11 @@ export function createConversationAgent(deps) {
         // preprint has no MEDLINE record, thus PubMed alone cannot answer it.
         createSearchSemanticScholarTool({ ...(bioKeys.semanticScholar === undefined ? {} : { apiKey: bioKeys.semanticScholar }) }),
         searchArxivTool,
+        // The web step of research — the injected web-search engine (the CLI runs
+        // SearXNG and binds its realization), then the guarded page fetch that
+        // reads what the search found.
+        ...(webSearch ? [createWebSearchTool({ engine: webSearch })] : []),
+        createWebFetchTool({ ...(toolOutputStore ? { toolOutputStore } : {}) }),
         // ChEMBL (compounds / drug / mechanism / bioactivity / targets behind one action).
         chemblTool,
         // PubChem (compound / crossrefs / assays behind one action).
@@ -109,6 +117,11 @@ export function createConversationAgent(deps) {
         // blind is how a user gets asked to download something already installed, or
         // told nothing is missing when it is; this is the only tool that can tell.
         createListAvailableRefsTool({ ...(refStorePath ? { refStorePath } : {}) }),
+        // Which datasets a specialist capability cannot run without. `list_available_refs` answers
+        // what the store HOLDS; this answers what a capability WANTS, which no prompt may name and
+        // only a skill otherwise records — and a skill is read by a step agent, not here. Without
+        // it this agent meets an absent source as a dead end and designs around it.
+        createInspectCapabilityDataTool({ ...(refStorePath ? { refStorePath } : {}) }),
         // What the STORE holds, pool-scope where the embedder binds the reader:
         // the ask flow of this agent marks the packages the pool does not hold,
         // and the farm of a new analysis is empty — a farm view here would read
@@ -130,6 +143,7 @@ export function createConversationAgent(deps) {
             usageRecorder,
             ...(toolOutputStore ? { toolOutputStore } : {}),
             bioKeys,
+            ...(deps.knowledge ? { knowledge: deps.knowledge } : {}),
             ...(refStorePath ? { refStorePath } : {}),
             ...(farmLockFile ? { farmLockFile } : {}),
             ...(imagePackagesFile ? { imagePackagesFile } : {}),
@@ -147,6 +161,10 @@ export function createConversationAgent(deps) {
             ...(farmLockFile ? { farmLockFile } : {}),
             ...(imagePackagesFile ? { imagePackagesFile } : {}),
             ...(readPoolInventory ? { readPoolInventory } : {}),
+            // The pre-launch pass resolves the declared reference data of a capability against the
+            // store. Without this path it would read the CONTAINER path, which no host holds, and
+            // refuse every launch of a plan that declares one.
+            ...(refStorePath ? { refStorePath } : {}),
             ...(deps.extendAnalysisFarm ? { extendAnalysisFarm: deps.extendAnalysisFarm } : {}),
             ...(deps.logger ? { logger: deps.logger } : {}),
             ...(usageRecorder ? { usageRecorder } : {}),

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

@@ -31,11 +31,19 @@ import type { AgentMeta, SandboxToolName } from "./types.js";
 import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
 import type { Logger } from "../../lib/logger.js";
 import type { CitationResolver } from "../../citations/types.js";
+import { type KnowledgeClient, type TemplateBinding } from "../../tools/knowledge/index.js";
 /**
  * Tools every sandbox agent receives — sandbox-environment introspection,
- * library docs, and run inspection. Spread into each agent's
- * `meta.tools` so planner-facing metadata and the resolved tool record
+ * library docs, run inspection, and the knowledge template. Spread into each
+ * agent's `meta.tools` so planner-facing metadata and the resolved tool record
  * stay in sync. Keep minimal — only tools every agent genuinely needs.
+ *
+ * The knowledge template is here, not on a specialist, because the template
+ * follows the step: the planner binds a template to a step from the
+ * recommendation and routes that step to whichever specialist owns its data
+ * object. The tool acts only on the template the step grounding names, thus
+ * a step without a template costs nothing, and it attaches only when the
+ * embedder binds a knowledge client (see the registry below).
  */
 export declare const BASE_SANDBOX_TOOLS: readonly SandboxToolName[];
 /** Per-step coordinates the composition root threads through every mutate tool. */
@@ -48,6 +56,12 @@ export interface SandboxStepCoords {
     readonly allowedWritePrefix: string;
     /** Absolute unix-ms deadline of each exec. */
     readonly deadlineMs: () => number;
+    /**
+     * The plan settings bound to the template of this step, from the durable
+     * step input. Reaches `knowledge_template` alone. Absent when the step
+     * grounds on no template, or when the host bound nothing.
+     */
+    readonly templateBinding?: TemplateBinding;
 }
 /** The shared dependency graph every sandbox agent draws from. */
 export interface SandboxAgentDeps extends EnvironmentStorePaths {
@@ -95,6 +109,13 @@ export interface SandboxAgentDeps extends EnvironmentStorePaths {
      * and the package-link prompt layer appends. Without it, neither exists.
      */
     readonly extendAnalysisFarm?: ExtendAnalysisFarm;
+    /**
+     * The knowledge service client. Bound, an agent that declares
+     * `knowledgeTemplate` gets the tool, over the same mutator as `write_file`.
+     * Absent, the declaration resolves to nothing, which is the default state
+     * of the open-source host and never an error.
+     */
+    readonly knowledge?: KnowledgeClient;
 }
 /** Per-agent override for the prompt composition and tool surface. */
 export interface SandboxAgentPromptOptions {

package/dist/agents/sandbox/shared.js

@@ -42,19 +42,34 @@ import { createSubmitFileMetadataTool } from "../../tools/sandbox/submit-file-me
 import { toSandboxPath } from "../../workspace/paths.js";
 import { SANDBOX_AGENT_DEFAULT_MAX_ITERATIONS } from "./types.js";
 import { createResolveCitationTool } from "../../tools/research/resolve-citation.js";
+import { createKnowledgeTemplateTool } from "../../tools/knowledge/index.js";
 /**
  * Tools every sandbox agent receives — sandbox-environment introspection,
- * library docs, and run inspection. Spread into each agent's
- * `meta.tools` so planner-facing metadata and the resolved tool record
+ * library docs, run inspection, and the knowledge template. Spread into each
+ * agent's `meta.tools` so planner-facing metadata and the resolved tool record
  * stay in sync. Keep minimal — only tools every agent genuinely needs.
+ *
+ * The knowledge template is here, not on a specialist, because the template
+ * follows the step: the planner binds a template to a step from the
+ * recommendation and routes that step to whichever specialist owns its data
+ * object. The tool acts only on the template the step grounding names, thus
+ * a step without a template costs nothing, and it attaches only when the
+ * embedder binds a knowledge client (see the registry below).
  */
-export const BASE_SANDBOX_TOOLS = ["listAvailablePackages", "listAvailableRefs", "resolveLibraryId", "queryDocs", "inspectRun"];
+export const BASE_SANDBOX_TOOLS = [
+    "listAvailablePackages",
+    "listAvailableRefs",
+    "resolveLibraryId",
+    "queryDocs",
+    "inspectRun",
+    "knowledgeTemplate",
+];
 /**
  * Resolve `meta.tools` into the bio/research tools record. The workspace
  * read/mutate tools and `inspect_data_profile` are added by `createSandboxAgent`
  * regardless of meta — they are the always-on substrate, not in the allowlist.
  */
-function resolveSandboxTools(deps, tools) {
+function resolveSandboxTools(deps, tools, mutator) {
     const ncbi = createNcbiTools(deps.bioKeys);
     const chemDb = createChemDbTools(deps.bioKeys, { ...(deps.logger ? { logger: deps.logger } : {}) });
     const amass = createAmassTools(deps.bioKeys);
@@ -97,6 +112,15 @@ function resolveSandboxTools(deps, tools) {
         searchRegulatoryApprovals: amass.regulatoryApprovals,
         targetSafety: targetSafetyTool,
         comptox: chemDb.comptox,
+        knowledgeTemplate: deps.knowledge && mutator
+            ? createKnowledgeTemplateTool({
+                client: deps.knowledge,
+                mutator,
+                ...(deps.farmLockFile ? { farmLockFile: deps.farmLockFile } : {}),
+                ...(deps.imagePackagesFile ? { imagePackagesFile: deps.imagePackagesFile } : {}),
+                ...(deps.step.templateBinding ? { binding: deps.step.templateBinding } : {}),
+            })
+            : undefined,
     };
     const seen = new Set();
     const resolved = [];
@@ -105,6 +129,12 @@ function resolveSandboxTools(deps, tools) {
             continue;
         seen.add(name);
         const tool = registry[name];
+        // The knowledge template is the one optional member of the allowlist: every
+        // agent lists it through BASE_SANDBOX_TOOLS, and it attaches only when the
+        // embedder binds a client and the agent can write. Absence is a normal
+        // state, not a wiring fault.
+        if (name === "knowledgeTemplate" && !tool)
+            continue;
         if (!tool) {
             throw new Error(`createSandboxAgent: unknown SandboxToolName "${name}" — ` + `agent meta references a tool with no harness implementation.`);
         }
@@ -124,24 +154,25 @@ function buildWorkspaceTools(deps, readOnly) {
     // it is correct for non-step agents such as the data profiler too.
     const hostWorkingDir = step.allowedWritePrefix;
     const sandboxWorkingDir = toSandboxPath(step.workspaceRoot, step.analysisId, hostWorkingDir);
-    const mutateTools = readOnly
-        ? []
-        : (() => {
-            const mutator = createWorkspaceMutator({
-                workspaceRoot: step.workspaceRoot,
-                analysisId: step.analysisId,
-                workingDir: hostWorkingDir,
-                ...(lineageCollector ? { lineageCollector } : {}),
-            });
-            return [createWriteFileTool({ mutator }), createEditFileTool({ mutator, workspaceFilesystem: workspaceFs, workingDir: hostWorkingDir })];
-        })();
-    return [
+    const mutator = readOnly
+        ? undefined
+        : createWorkspaceMutator({
+            workspaceRoot: step.workspaceRoot,
+            analysisId: step.analysisId,
+            workingDir: hostWorkingDir,
+            ...(lineageCollector ? { lineageCollector } : {}),
+        });
+    const mutateTools = mutator
+        ? [createWriteFileTool({ mutator }), createEditFileTool({ mutator, workspaceFilesystem: workspaceFs, workingDir: hostWorkingDir })]
+        : [];
+    const tools = [
         createExecuteCommandTool({
             sandboxClient,
             sandbox: step.sandbox,
             deadlineMs: step.deadlineMs,
             defaultCwd: sandboxWorkingDir,
             ...(lineageCollector ? { lineageCollector, mountRoot: `/${step.analysisId}` } : {}),
+            ...(mutator ? { workspaceFilesystem: workspaceFs, mutator } : {}),
         }),
         ...mutateTools,
         createReadFileTool(workspaceFs, hostWorkingDir),
@@ -150,6 +181,7 @@ function buildWorkspaceTools(deps, readOnly) {
         createGrepTool(workspaceFs, hostWorkingDir),
         ...(embedding ? [createWorkspaceSearchTool(pool, embedding)] : []),
     ];
+    return { tools, mutator };
 }
 /**
  * Build one sandbox `AgentDefinition`. The system prompt is composed once
@@ -185,8 +217,9 @@ export function createSandboxAgent(deps, meta, body, opts = {}) {
     const agentBody = [body, ...sandboxLayer].map((s) => s.trim()).join("\n\n");
     const systemPrompt = composeSystemPrompt(agentBody);
     const skillTools = deps.skillsDir ? Object.values(createSkillTools({ skillsDir: deps.skillsDir, skills: meta.skills })) : [];
+    const workspace = buildWorkspaceTools(deps, opts.readOnly ?? false);
     const tools = [
-        ...buildWorkspaceTools(deps, opts.readOnly ?? false),
+        ...workspace.tools,
         ...(deps.toolOutputStore ? [createReadToolOutputTool(deps.toolOutputStore)] : []),
         // Always-on, not in the `meta.tools` allowlist: the data profile is the only
         // record of what the analysis's input dataset IS, and no file carries it (the
@@ -199,7 +232,7 @@ export function createSandboxAgent(deps, meta, body, opts = {}) {
         // seam (the harness-sandbox-agents spec).
         ...(deps.extendAnalysisFarm ? [createLinkPackagesTool({ extendAnalysisFarm: deps.extendAnalysisFarm, analysisId: deps.step.analysisId })] : []),
         ...skillTools,
-        ...resolveSandboxTools(deps, meta.tools),
+        ...resolveSandboxTools(deps, meta.tools, workspace.mutator),
         ...(deps.blockerHolder ? [createReportBlockerTool(deps.blockerHolder)] : []),
         ...(deps.fileMetadata ? [createSubmitFileMetadataTool(deps.fileMetadata)] : []),
     ];

package/dist/agents/sandbox/translational-safety-agent.js

@@ -3,6 +3,11 @@
  */
 import { translationalSafetyAgentPrompt } from "../../prompts/sandbox/translational-safety-agent.js";
 import { BASE_SANDBOX_TOOLS, createSandboxAgent } from "./shared.js";
+/**
+ * Named once, because the capability phrase is the key of its own data requirement below and a
+ * plan step copies it verbatim. Two spellings of one capability would lose the pre-launch check.
+ */
+const MATCHED_NEGATIVE_CAPABILITY = "matched negative gene set for a tissue risk benchmark (annotation_free or tested_clean negatives) matched on tissue expression and PPI connectivity with mouse and human phenotype annotation exclusions";
 export const meta = {
     id: "translational-safety-agent",
     capabilities: [
@@ -20,6 +25,8 @@ export const meta = {
         "hematological toxicity assessment",
         "mouse KO phenotype lookup",
         "cross-species baseline expression lookup",
+        MATCHED_NEGATIVE_CAPABILITY,
+        "expression and PPI connectivity matching",
     ],
     suitableFor: [
         "safety-biomarkers",
@@ -29,6 +36,25 @@ export const meta = {
         "clinical-safety-labs",
         "drug-interaction-data",
         "pharmacogenomic-data",
+        "gene-lists",
+    ],
+    // The method of this capability reads six opt-in datasets. Without any one of them a negatives
+    // file would carry a label the run cannot defend, so the launch refuses rather than spend a run.
+    // The recommended datasets it also reads (the expression table, the network, the gene tables,
+    // the GO collection) stay out: a default store holds them, and declaring one would refuse a
+    // launch an embedder already provisioned.
+    dataRequirements: [
+        {
+            capability: MATCHED_NEGATIVE_CAPABILITY,
+            datasets: [
+                "string-aliases-human",
+                "mgi-mouse-human-homology",
+                "impc-phenotyping",
+                "hpo-annotations",
+                "opentargets-mouse-phenotype",
+                "opentargets-target-safety-event",
+            ],
+        },
     ],
     skills: ["translational-safety", "cheminformatics", "shared/omics-general"],
     tools: [

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

@@ -12,7 +12,21 @@
  * 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";
+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";
+/**
+ * The reference datasets that one capability of one agent cannot run without.
+ *
+ * A requirement belongs to a capability, never to the agent: an agent holds capabilities that need
+ * no reference data at all, so an agent-wide requirement would refuse a step that needs nothing.
+ * The skill of the agent still states what the data IS and how to use it. This states which catalog
+ * entry carries it, in a form a test can pin.
+ */
+export interface CapabilityDataRequirement {
+    /** One phrase of the same agent's `capabilities`, verbatim — the step copies it from the catalog. */
+    readonly capability: string;
+    /** Reference-catalog dataset ids. Declare only an opt-in dataset: a recommended one is already in a default store. */
+    readonly datasets: readonly string[];
+}
 /** Planner-facing metadata + tool allowlist for one sandbox agent. */
 export interface AgentMeta {
     /** Stable agent id — also the key in the catalog and the `AgentDefinition.id`. */
@@ -29,6 +43,15 @@ export interface AgentMeta {
     readonly defaultMaxSteps?: number;
     /** False for agents the planner must NOT assign to plan steps (executors, the profiler). */
     readonly plannable?: boolean;
+    /**
+     * Per-capability reference-data requirements. Omitted by an agent whose capabilities all run on
+     * what a default store holds.
+     *
+     * The pre-launch pass resolves these against the live store, so an absent dataset refuses the
+     * launch instead of costing a run. The planner-facing projection deliberately drops this field:
+     * a prompt names no dataset, so the ids reach a caller through a tool and the launch through here.
+     */
+    readonly dataRequirements?: readonly CapabilityDataRequirement[];
 }
 /** Default runaway-guard for sandbox agents. */
 export declare const SANDBOX_AGENT_DEFAULT_MAX_ITERATIONS = 200;

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

@@ -15,6 +15,20 @@ export interface PlannerAgentMeta {
 }
 /** The sandbox agents the planner may assign to analysis-plan steps. */
 export declare const PLANNABLE_AGENT_CATALOG: readonly PlannerAgentMeta[];
+/**
+ * The reference datasets one capability of one agent cannot run without, by catalog id.
+ *
+ * Empty for an unknown agent, for an agent that declares nothing, and for a phrase no declaration
+ * matches. An unmatched phrase must NOT refuse a launch: the pass can only demand what a
+ * declaration states, so a paraphrased phrase degrades to the behaviour of a step with no phrase.
+ */
+export declare function capabilityDataRequirement(agentId: string, capability: string): readonly string[];
+/** Every declared requirement, for a caller that asks what a capability wants before it plans. */
+export declare function declaredDataRequirements(): readonly {
+    agentId: string;
+    capability: string;
+    datasets: readonly string[];
+}[];
 /**
  * Ids of the agents the planner may assign — the `z.enum` domain for
  * `PlanStepSchema.agent`. A non-empty tuple, as `z.enum` requires.

package/dist/agents/sandbox-catalog.js

@@ -16,6 +16,25 @@ export const PLANNABLE_AGENT_CATALOG = Object.values(SANDBOX_AGENT_META)
     capabilities: [...meta.capabilities],
     suitableFor: [...meta.suitableFor],
 }));
+/**
+ * The reference datasets one capability of one agent cannot run without, by catalog id.
+ *
+ * Empty for an unknown agent, for an agent that declares nothing, and for a phrase no declaration
+ * matches. An unmatched phrase must NOT refuse a launch: the pass can only demand what a
+ * declaration states, so a paraphrased phrase degrades to the behaviour of a step with no phrase.
+ */
+export function capabilityDataRequirement(agentId, capability) {
+    const entry = SANDBOX_AGENT_META[agentId]?.dataRequirements?.find((requirement) => requirement.capability === capability);
+    return entry?.datasets ?? [];
+}
+/** Every declared requirement, for a caller that asks what a capability wants before it plans. */
+export function declaredDataRequirements() {
+    return Object.values(SANDBOX_AGENT_META).flatMap((meta) => (meta.dataRequirements ?? []).map((requirement) => ({
+        agentId: meta.id,
+        capability: requirement.capability,
+        datasets: requirement.datasets,
+    })));
+}
 /**
  * Ids of the agents the planner may assign — the `z.enum` domain for
  * `PlanStepSchema.agent`. A non-empty tuple, as `z.enum` requires.

package/dist/app/approve-plan.d.ts

@@ -23,12 +23,15 @@ export type ApprovePlanInput = {
     analysisId: string;
     threadId: string;
     planId: string;
+    /** The newest run of the plan in the view that the person approved, or `null` when that view showed no run. */
+    newestRunId: string | null;
     identity: Identity;
     auth: AuthContext;
 };
 /**
- * The outcome of an approval. `started` is false when a run of the plan was already active: the
- * approval then changed nothing, and `message` is `null`. `message` is also `null` when the record
+ * The outcome of an approval. `started` is false when a run of the plan was already active, or when the
+ * view of the person was stale: the approval then changed nothing, `runId` names the active run or the
+ * newest run of the plan, and `message` is `null`. `message` is also `null` when the record
  * could not be appended, because the run started anyway. It has no `createdAt`: the transcript read
  * adds the time of the row.
  */

package/dist/app/approve-plan.js

@@ -55,7 +55,7 @@ async function approve(deps, input) {
         scope: { kind: "analysis", analysisId, threadId },
         provenance: APPROVAL_PROVENANCE,
     };
-    const launched = await launchPlanRun(deps, { session, planId });
+    const launched = await launchPlanRun(deps, { session, planId, newestRunId: input.newestRunId });
     if (launched.isErr())
         return err(launched.error);
     const { runId, started } = launched.value;

package/dist/app/chat-turn.js

@@ -4,6 +4,7 @@
  * values, and the harness stores the opening, each round, and the outcome.
  */
 import { unwrapOrThrow } from "../lib/result.js";
+import { rulesForContextWindow } from "../loop/compaction.js";
 import { finalText, runAgent } from "../loop/run-agent.js";
 import { passthroughStep } from "../loop/run-step.js";
 import { compactionExchangeOf, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
@@ -244,10 +245,12 @@ function compactionPolicy(deps, analysisId, params, threadType, agent, emit) {
     // A report thread reads a frozen copy of the working memory, thus its agent declares no memory tool.
     const remembers = agent.tools.some((tool) => tool.id === WORKING_MEMORY_TOOL_ID);
     const workingMemory = createWorkingMemory(deps.pool);
+    // A streaming provider sends each text delta with no source, thus a delta of the summary would show as a reply.
+    const provider = params.chat((event) => (event.type === "text-delta" ? undefined : emit(event)));
     return {
-        ...agent.compaction,
-        // A streaming provider sends each text delta with no source, thus a delta of the summary would show as a reply.
-        provider: params.chat((event) => (event.type === "text-delta" ? undefined : emit(event))),
+        // The capabilities are read for each turn, because a host can switch the model of the conversation between turns.
+        ...rulesForContextWindow(agent.compaction, provider.capabilities.contextWindow),
+        provider,
         request: remembers ? MEMORY_COMPACTION_REQUEST : SUMMARY_COMPACTION_REQUEST,
         mask: remembers ? { allow: [WORKING_MEMORY_TOOL_ID] } : "none",
         keepFirstTurn: threadType === "report",

package/dist/config/environment-stores.d.ts

@@ -49,8 +49,10 @@ export interface EnvironmentStorePaths {
     readonly farmLockFile?: string | ((analysisId: string) => string);
     /**
      * Host path of the image inventory record, `image-packages.json` at the
-     * root of the package store — the image-owned tools and Node packages
-     * that `list_available_packages` merges into its report. Omit when the
+     * root of the package store — the image-owned tools, the Node packages,
+     * and the R packages that ship with the R runtime, which
+     * `list_available_packages` merges into its report and which the
+     * knowledge tools read for the environment of a step. Omit when the
      * host's own process sees the store at the container mountpoint, which
      * makes `/mnt/libs/image-packages.json` correct as-is; set it when the
      * host reads the store somewhere else. An absent or invalid record

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

@@ -1,7 +1,7 @@
 /**
  * Chat-stream events — the harness wire vocabulary.
  *
- * Distinct from the 15 `data-*` chat parts (`chat-parts.ts`): those are UI
+ * Distinct from the `data-*` chat parts (`chat-parts.ts`): those are UI
  * presentation payloads a tool emits; these are the agent-loop stream events
  * the host chat route frames as SSE. Together they are the sole
  * host↔frontend wire contract — there is no AI SDK UI Message Stream
@@ -142,8 +142,18 @@ export interface ChatErrorEvent {
     reason?: string;
     source: EventSource;
 }
+/**
+ * The id that the stored display gives a message of the turn. The frames after it belong to that message, up to
+ * the next `message-start` of the same role.
+ */
+export interface MessageStartEvent {
+    type: "message-start";
+    messageId: string;
+    role: "user" | "assistant";
+    source: EventSource;
+}
 /** The discriminated union of all chat-stream events. */
-export type ChatEvent = TextDeltaEvent | IterationEvent | ToolStartedEvent | ToolFinishedEvent | FinishEvent | ChatErrorEvent;
+export type ChatEvent = TextDeltaEvent | IterationEvent | ToolStartedEvent | ToolFinishedEvent | FinishEvent | ChatErrorEvent | MessageStartEvent;
 /** A `data-*` part as a frame, with the source of its emitter when the emitter stamped one. */
 export type ChatPartFrame = ChatPart & {
     source?: EventSource;

package/dist/contracts/chat-events.js

@@ -1,7 +1,7 @@
 /**
  * Chat-stream events — the harness wire vocabulary.
  *
- * Distinct from the 15 `data-*` chat parts (`chat-parts.ts`): those are UI
+ * Distinct from the `data-*` chat parts (`chat-parts.ts`): those are UI
  * presentation payloads a tool emits; these are the agent-loop stream events
  * the host chat route frames as SSE. Together they are the sole
  * host↔frontend wire contract — there is no AI SDK UI Message Stream

package/dist/contracts/chat-frame.js

@@ -53,6 +53,8 @@ export function toChatFrame(event, fallbackSource) {
             };
         case "text-delta":
             return { type: "text-delta", text: event.text, source: toSource(fallbackSource) };
+        case "message-start":
+            return { type: "message-start", messageId: event.messageId, role: event.role, source: toSource(event.source) };
         default: {
             // The cast names the frame that the type claims. `checkChatPart` is the check.
             const part = flattenDataPart(event);
@@ -117,7 +119,7 @@ export function applyChatFrame(messages, frame, assistantId) {
     if (frame.type === "error") {
         return { messages, terminal: { error: frame } };
     }
-    if (frame.type === "iteration")
+    if (frame.type === "iteration" || frame.type === "message-start")
         return { messages, terminal: null };
     const partFrame = frame;
     const next = updateAssistant(messages, assistantId, (parts) => applyPartFrame(parts, partFrame));
@@ -157,9 +159,11 @@ function applyPartFrame(parts, frame) {
             return started ? next : [...parts, finished];
         }
         default: {
+            // A chat event type that no case above takes is not a part frame, thus this annotation fails to compile.
+            const partFrame = frame;
             // The source routes the frame, and it is not a field of the part. A rest type does not distribute over the
             // union of the part frames, thus the cast names the part that remains.
-            const { source: _source, ...part } = frame;
+            const { source: _source, ...part } = partFrame;
             return upsertPart(parts, part);
         }
     }

package/dist/contracts/index.d.ts

@@ -3,7 +3,7 @@ export type { OrganSystem } from "./organ-system.js";
 export { SEVERITIES, SeveritySchema } from "./severity.js";
 export type { Severity } from "./severity.js";
 export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, ChatPart, } from "./chat-parts.js";
-export type { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
+export type { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, MessageStartEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export type { DataProfileAxis, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileCoverage, DataProfileDimension, DataProfileFile, DataProfileGroup, DataProfileGroupSlot, DataProfileInputSignature, DataProfileKind, DataProfileLifecycleStatus, DataProfileMemberAnnotation, DataProfileObservation, DataProfileOrganism, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileResult, DataProfileSubjectSource, } from "./data-profile.js";

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

@@ -97,6 +97,19 @@ export declare const ChatErrorEventSchema: z.ZodObject<{
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const MessageStartEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"message-start">;
+    messageId: z.ZodUUID;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    source: z.ZodObject<{
+        agentId: z.ZodString;
+        callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"text-delta">;
     text: z.ZodString;
@@ -168,4 +181,16 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message-start">;
+    messageId: z.ZodUUID;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        user: "user";
+    }>;
+    source: z.ZodObject<{
+        agentId: z.ZodString;
+        callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
 }, z.core.$strip>], "type">;

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

@@ -50,6 +50,12 @@ export const ChatErrorEventSchema = z.object({
     reason: z.string().optional(),
     source: EventSourceSchema,
 });
+export const MessageStartEventSchema = z.object({
+    type: z.literal("message-start"),
+    messageId: z.uuid(),
+    role: z.enum(["user", "assistant"]),
+    source: EventSourceSchema,
+});
 export const ChatEventSchema = z.discriminatedUnion("type", [
     TextDeltaEventSchema,
     IterationEventSchema,
@@ -57,4 +63,5 @@ export const ChatEventSchema = z.discriminatedUnion("type", [
     ToolFinishedEventSchema,
     FinishEventSchema,
     ChatErrorEventSchema,
+    MessageStartEventSchema,
 ]);