@inflexa-ai/harness 0.46.2 → 0.47.0

package/dist/state/step-executions.js

@@ -1,7 +1,5 @@
 /**
  * `cortex_step_executions` operations — step lifecycle and retry telemetry.
- * The `sandbox_ref` column is read/written by the sibling `active-sandboxes`
- * module.
  */
 import { tryMutation, tryQuery } from "../lib/db-result.js";
 import { StepExecutionRowSchema } from "./schema.js";
@@ -165,7 +163,7 @@ export function queryStepsByRun(pool, runId) {
             text: `SELECT run_id, step_id, analysis_id, wave, agent_id,
                  status, started_at, completed_at, duration_ms, error,
                  attempts, last_error_class, finish_reason, hit_max_steps,
-                 blocked_reason, sandbox_ref, child_workflow_id
+                 blocked_reason, child_workflow_id
           FROM cortex_step_executions
           WHERE run_id = $1
           ORDER BY wave, started_at NULLS LAST, step_id`,
@@ -192,7 +190,6 @@ function mapStepExecutionRow(row) {
         finishReason: row.finish_reason ?? null,
         hitMaxSteps: row.hit_max_steps === 1 || row.hit_max_steps === true,
         blockedReason: row.blocked_reason ?? null,
-        sandboxRef: row.sandbox_ref ?? null,
         childWorkflowId: row.child_workflow_id ?? null,
     });
 }

package/dist/tasks/data-profile.d.ts

@@ -17,6 +17,7 @@
  * triggers dedup via the ledger CAS (only one `tryStart/tryRerun/tryRetry`
  * UPDATE wins); each winning attempt starts a workflow under a per-attempt id.
  */
+import type { ScriptRuntime } from "../tools/script/run-script.js";
 import { ResultAsync } from "neverthrow";
 import { type AuthContext, type RunSession } from "../auth/types.js";
 import type { EnvironmentStorePaths } from "../config/environment-stores.js";
@@ -32,13 +33,46 @@ import type { Querier } from "../state/db.js";
 import { type GateRefusal, type NoticeFailure } from "../lib/hooks.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
+import { type Tool } from "../tools/define-tool.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
-import type { SandboxClient } from "../sandbox/client.js";
+import type { ResourceSpec } from "../config/resource-limits.js";
+import type { SandboxLeases } from "../sandbox/leases.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
+import { z } from "zod";
 import { type ProfileSubmission } from "../schemas/data-profile-schemas.js";
+import { type SetMenu } from "../input-scan/menu.js";
+import type { DetectedSets } from "../input-scan/set-types.js";
+import { type AbsorbOutcome } from "./data-profile-absorb.js";
 import { type ProfileResolution } from "./data-profile-resolve.js";
 import { type DataProfileResult } from "../state/index.js";
+/** What one call of `submit_profile` tells the agent. */
+declare const SubmitOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"needs_repair">;
+    detail: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"accepted">;
+    groups: z.ZodNumber;
+    keptFiles: z.ZodNumber;
+    unclassifiedFiles: z.ZodNumber;
+    unresolvedOperations: z.ZodNumber;
+}, z.core.$strip>], "status">;
+type SubmitOutcome = z.infer<typeof SubmitOutcomeSchema>;
+/**
+ * The first message of the profiler. No scheduler composes a briefing for it, thus this message is its briefing: the
+ * system prompt names no paths, because it is static for each agent type. The workspace frame and the resource budget
+ * use the same words as the step briefing.
+ */
+export declare function composeProfilerSeed(args: {
+    readonly analysisId: string;
+    /** The in-sandbox working directory of the profiler. */
+    readonly workingDir: string;
+    readonly resources: ResourceSpec;
+    readonly menu: SetMenu;
+    readonly absorb: AbsorbOutcome;
+}): string;
+/** The terminal tool of the profiler: it resolves the operations of a submission against the scan and the menu. */
+export declare function createSubmitProfileTool(detected: DetectedSets, menu: SetMenu): Tool<ProfileSubmission, SubmitOutcome>;
 /** The settle of one profile claim: the ledger row left `running`, and the terminal write stamped it. */
 export type DataProfileSettlement = {
     readonly analysisId: string;
@@ -54,7 +88,8 @@ export type DataProfileDeps = EnvironmentStorePaths & {
     readonly logger?: Logger;
     readonly provider: ChatProvider;
     readonly pool: Querier;
-    readonly sandboxClient: SandboxClient;
+    /** The sandbox module. The profile acquires its lease from it, and its agent runs commands on that lease. */
+    readonly leases: SandboxLeases;
     readonly workspaceFs: WorkspaceFilesystem;
     /** Workspace-root resolution seam (see workspace/paths.ts). */
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
@@ -90,6 +125,8 @@ export type DataProfileDeps = EnvironmentStorePaths & {
     readonly notifyDataProfileSettled?: NotifyDataProfileSettled;
     /** The delays of the timer of an outage. Absent: the default of the pause. */
     readonly pauseRetryDelaysMs?: readonly number[];
+    /** Where the VM of `run_script` comes from, for the lookups of the profiler. */
+    readonly scriptRuntime?: ScriptRuntime;
 };
 /**
  * Workflow input. JSON-serialisable — DBOS persists it as the workflow's
@@ -270,3 +307,4 @@ export type DataProfileStopDeps = {
  * teardown of the sandbox stay in the body, which runs them on its way out. The `running` guard of the row write keeps a profile that settled first.
  */
 export declare function stopDataProfile(deps: DataProfileStopDeps, analysisId: string, workflowId: string): Promise<void>;
+export {};

package/dist/tasks/data-profile.js

@@ -27,21 +27,19 @@ import { forStep, forSubAgent } from "../auth/types.js";
 import { presentFirst } from "../lib/present.js";
 import { collapseWhitespace } from "../lib/text.js";
 import { createDataProfilerAgent } from "../agents/sandbox/data-profiler.js";
-import { runWithSalvage } from "../loop/run-loop.js";
+import { runWithSalvage, withRunScript } from "../loop/run-loop.js";
 import { recordedInputOf } from "../loop/tool-adapter.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { deliverNotice, passGate } from "../lib/hooks.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { defineTool } from "../tools/define-tool.js";
 import { createDetailResolver } from "../tools/detail-resolver.js";
-import { renderWorkspace } from "../prompts/briefing.js";
-import { keepSuspendingRefusal, SandboxFailure } from "../sandbox/sandbox-error.js";
+import { renderResources, renderWorkspace } from "../prompts/briefing.js";
 import { workPause } from "../workflows/pause.js";
 import { clearPausesOfWork } from "../state/paused-work.js";
-import { toSandboxPath } from "../workspace/paths.js";
+import { STAGED_INPUT_ROOT, toSandboxPath } from "../workspace/paths.js";
 import { estimateDataProfileResources } from "../sandbox/estimate-data-profile-resources.js";
 import { generateExecutionId } from "../sandbox/execution-id.js";
-import { mintSandboxIdentity } from "../sandbox/identity.js";
 import { createVectorStore } from "../state/vector-store.js";
 import { z } from "zod";
 import { ProfileSubmissionSchema } from "../schemas/data-profile-schemas.js";
@@ -63,12 +61,6 @@ import { ensureSearchIndex, searchIndexName } from "../workspace/search-config.j
 import { DATA_PROFILE_RUN_LITERAL } from "../contracts/data-profile.js";
 const DATA_PROFILE_STEP_LITERAL = "profile";
 const DATA_PROFILE_AGENT_ID = "data-profiler";
-/**
- * Sandbox-server exec budget for the profile run. Twenty minutes: the deterministic
- * scan bounds the discovery half, and what remains is the agent's own reading of a
- * bounded number of example files.
- */
-const DEFAULT_DEADLINE_MS = 1_200_000;
 /** Index entries embedded and upserted per round trip. */
 const INDEX_BATCH_SIZE = 256;
 const SUBMIT_PROFILE_TOOL_ID = "submit_profile";
@@ -83,6 +75,56 @@ const SubmitOutcomeSchema = z.discriminatedUnion("status", [
         unresolvedOperations: z.number(),
     }),
 ]);
+/**
+ * The first message of the profiler. No scheduler composes a briefing for it, thus this message is its briefing: the
+ * system prompt names no paths, because it is static for each agent type. The workspace frame and the resource budget
+ * use the same words as the step briefing.
+ */
+export function composeProfilerSeed(args) {
+    return [
+        `Profile the input data for this analysis: say what the dataset IS, so planning can proceed.`,
+        ``,
+        renderWorkspace({ analysisId: args.analysisId, workingDir: args.workingDir }),
+        ``,
+        renderResources(args.resources),
+        ``,
+        renderSetMenu(args.menu, STAGED_INPUT_ROOT),
+        ``,
+        ...(args.absorb.kind === "partial"
+            ? [renderAbsorbDelta(args.absorb), ``]
+            : [
+                `Author the dataset's groups as operations on this menu: \`use\` a set, \`split\` one by a slot or by a`,
+                `value mapping, \`merge\` several, or \`group\` explicit paths the scan left over. Membership and counts`,
+                `are computed from your operations — you do not state them. Inspect ONE example file per group where a`,
+                `description needs content the scan did not capture, then deliver the groups with \`submit_profile\`.`,
+            ]),
+    ].join("\n");
+}
+/** The terminal tool of the profiler: it resolves the operations of a submission against the scan and the menu. */
+export function createSubmitProfileTool(detected, menu) {
+    return defineTool({
+        id: SUBMIT_PROFILE_TOOL_ID,
+        description: "Submit the profiling results. Call this tool after completing all profiling work — it resolves your " +
+            "operations against the scan, computes every group's membership and counts, and checks the profile. " +
+            "A submission whose operations do not resolve, or that leaves kept files unclaimed, comes back with " +
+            "the errors; the repair is a FULL resubmit of the whole operation list. The last accepted submission is the profile.",
+        inputSchema: ProfileSubmissionSchema,
+        describeCall: "none",
+        execute: (input) => {
+            const resolution = resolveProfileSubmission(input, detected, menu, { finalRound: false });
+            if (resolution.errors.length > 0 || resolution.unclaimed.length > 0) {
+                return Promise.resolve(ok({ status: "needs_repair", detail: formatResolutionErrors(resolution) }));
+            }
+            return Promise.resolve(ok({
+                status: "accepted",
+                groups: resolution.groups.length,
+                keptFiles: resolution.partition.keptFiles,
+                unclassifiedFiles: resolution.partition.unclassifiedFiles,
+                unresolvedOperations: resolution.errors.length,
+            }));
+        },
+    });
+}
 /** The submissions of a run, in call order, with the outcome that the tool gave each one. */
 function profileSubmissions(steps) {
     const submissions = [];
@@ -110,8 +152,6 @@ function selectedSubmission(steps) {
     const chosen = submissions.filter((entry) => entry.accepted).at(-1) ?? submissions.at(-1);
     return chosen === undefined ? undefined : { ...chosen, count: submissions.length };
 }
-/** Where the embedder stages this analysis's inputs (see the data-profile-init spec). */
-const STAGED_INPUT_ROOT = "data/inputs";
 /** Build the canonical artifact path for a staged input file. */
 function inputArtifactPath(f) {
     return `data/${f.relativePath}`;
@@ -164,16 +204,14 @@ export function buildDataProfileResult(submission, resolution, stagedInputs, pro
  * rests on, so failing the profile over it would trade the whole capability for a nicety.
  */
 async function readSetHeaders(args) {
-    const { session, deps, analysisId, detected, sandbox, deadlineMs, logger } = args;
+    const { session, deps, analysisId, detected, lease, logger } = args;
     try {
         return await readHeaders({
             targets: readoutTargets(detected),
             session,
             fs: deps.workspaceFs,
-            sandboxClient: deps.sandboxClient,
-            sandbox,
+            lease,
             mountRoot: `/${analysisId}`,
-            deadlineMs,
             emit: async () => { },
         });
     }
@@ -298,7 +336,7 @@ export function profilerSandboxAgentDeps(deps, step) {
     return {
         provider: deps.provider,
         pool: deps.pool,
-        sandboxClient: deps.sandboxClient,
+        toolchainSource: deps.leases.toolchainSource,
         workspaceFs: deps.workspaceFs,
         embedding: deps.embedding,
         model: deps.model,
@@ -309,6 +347,7 @@ export function profilerSandboxAgentDeps(deps, step) {
         extendAnalysisFarm: deps.extendAnalysisFarm,
         toolOutputStore: deps.toolOutputStore,
         bioKeys: deps.bioKeys,
+        scriptRuntime: deps.scriptRuntime,
         step,
     };
 }
@@ -458,95 +497,57 @@ export async function runDataProfileBody(input, deps) {
         // from the agent loop would leave the longest wait of all unreported — the same defect the
         // run panel's activity readout was built to remove.
         await activity.sandboxInit();
-        const spawn = async () => keepSuspendingRefusal(await deps.sandboxClient.createSandbox(forStep(runSession, DATA_PROFILE_STEP_LITERAL), { childWorkflowId: workflowId, resources: estimateDataProfileResources(stagedInputs) }, mintSandboxIdentity(DATA_PROFILE_RUN_LITERAL)));
-        let spawned = await spawn();
-        // A refusal of the label gate with the suspend flag waits in a pause, and the spawn runs again after the
-        // resume. A body that runs outside a workflow cannot wait, thus the refusal fails the profile there.
-        while (spawned.isErr()) {
-            const waited = await pause.forCause({ kind: "host", reason: spawned.error.reason }, 0);
-            if (waited === undefined)
-                throw new SandboxFailure(spawned.error);
-            spawned = await spawn();
-        }
-        const sandbox = spawned.value;
+        // The lease of the profile. A refused spawn with the suspend flag pauses the lease workflow under the
+        // profile, and the acquire waits through the pause.
+        const lease = deps.leases.bind({
+            leaseKey: workflowId,
+            session: forStep(runSession, DATA_PROFILE_STEP_LITERAL),
+            work: { kind: "profile", id: workflowId },
+            emit: (part) => DBOS.writeStream("events", part),
+        });
+        const acquired = await lease.acquire(estimateDataProfileResources(stagedInputs));
+        if (acquired.kind === "refused")
+            throw new Error(acquired.reason);
+        if (acquired.kind === "failed")
+            throw new Error(`the profiler sandbox did not start: ${acquired.detail}`);
+        const resources = acquired.size;
         try {
-            // Checkpointed clock, not `Date.now()`: one deadline bounds every exec of the
-            // profile, and a wall-clock deadline would grow on each recovery (see
-            // sandbox-step.ts, which captures its step deadline the same way).
-            const deadlineAbs = (await DBOS.now()) + DEFAULT_DEADLINE_MS;
             const headers = await readSetHeaders({
                 session: childSession,
                 deps,
                 analysisId,
                 detected,
-                sandbox,
-                deadlineMs: deadlineAbs,
+                lease,
                 logger,
             });
             const briefingMenu = { ...menu, headers };
             // The profiler runs outside `executeAnalysis`, so no scheduler composes a
             // briefing for it — this prompt IS its briefing, and the sandbox system
             // prompt names no paths (it is static per agent type, for the prompt cache).
-            // Its workspace frame therefore has to be stated here, in the same words the
-            // step briefing uses.
-            const prompt = [
-                `Profile the input data for this analysis: say what the dataset IS, so planning can proceed.`,
-                ``,
-                renderWorkspace({
-                    analysisId,
-                    workingDir: toSandboxPath(workspaceRoot, analysisId, profileWritePrefix),
-                }),
-                ``,
-                `CRITICAL: File and directory paths may contain spaces. You MUST always double-quote paths in shell commands (e.g. head "/${analysisId}/data/inputs/My Folder/file.csv"). Unquoted paths with spaces will silently break commands.`,
-                ``,
-                renderSetMenu(briefingMenu, STAGED_INPUT_ROOT),
-                ``,
-                ...(absorb.kind === "partial"
-                    ? [renderAbsorbDelta(absorb), ``]
-                    : [
-                        `Author the dataset's groups as operations on this menu: \`use\` a set, \`split\` one by a slot or by a`,
-                        `value mapping, \`merge\` several, or \`group\` explicit paths the scan left over. Membership and counts`,
-                        `are computed from your operations — you do not state them. Inspect ONE example file per group where a`,
-                        `description needs content the scan did not capture, then call \`submit_profile\` once.`,
-                    ]),
-            ].join("\n");
+            // Its workspace frame and its resource budget therefore have to be stated here,
+            // in the same words the step briefing uses.
+            const prompt = composeProfilerSeed({
+                analysisId,
+                workingDir: toSandboxPath(workspaceRoot, analysisId, profileWritePrefix),
+                resources,
+                menu: briefingMenu,
+                absorb,
+            });
             const sandboxAgentDeps = profilerSandboxAgentDeps(deps, {
-                sandbox,
+                lease,
                 workspaceRoot,
                 analysisId,
                 // The profiler writes Python scripts and intermediate artifacts under
                 // the synthetic step path; the post-agent `rm -rf runs/data-profile/`
                 // cleanup wipes them.
                 allowedWritePrefix: profileWritePrefix,
-                deadlineMs: () => deadlineAbs,
-            });
-            const submitProfileTool = defineTool({
-                id: SUBMIT_PROFILE_TOOL_ID,
-                description: "Submit the profiling results. Call this tool after completing all profiling work — it resolves your " +
-                    "operations against the scan, computes every group's membership and counts, and checks the profile. " +
-                    "A submission whose operations do not resolve, or that leaves kept files unclaimed, comes back with " +
-                    "the errors; the repair is a FULL resubmit of the whole operation list. The last accepted submission is the profile.",
-                inputSchema: ProfileSubmissionSchema,
-                describeCall: "none",
-                execute: (input) => {
-                    const resolution = resolveProfileSubmission(input, detected, briefingMenu, { finalRound: false });
-                    if (resolution.errors.length > 0 || resolution.unclaimed.length > 0) {
-                        return Promise.resolve(ok({ status: "needs_repair", detail: formatResolutionErrors(resolution) }));
-                    }
-                    return Promise.resolve(ok({
-                        status: "accepted",
-                        groups: resolution.groups.length,
-                        keptFiles: resolution.partition.keptFiles,
-                        unclassifiedFiles: resolution.partition.unclassifiedFiles,
-                        unresolvedOperations: resolution.errors.length,
-                    }));
-                },
             });
+            const submitProfileTool = createSubmitProfileTool(detected, briefingMenu);
             const baseAgent = createDataProfilerAgent(sandboxAgentDeps);
             const agentDef = { ...baseAgent, tools: [...baseAgent.tools, submitProfileTool] };
             // The profiler's own roster, `submit_profile` included, so every call it
             // makes is phrased by the tool that was called.
-            const resolveDetail = createDetailResolver(agentDef.tools, logger);
+            const resolveDetail = createDetailResolver([...withRunScript(agentDef).tools, ...(agentDef.scriptTools ?? [])], logger);
             const signal = new AbortController().signal;
             // Covers the gap between a ready sandbox and the agent's first tool call, which would
             // otherwise still read as `Starting sandbox` long after the container was up. The run
@@ -609,15 +610,16 @@ export async function runDataProfileBody(input, deps) {
             // write above, the revoke — is already behind us, so any failure on the way here reaches
             // the catch having emitted no terminal at all and reports `failed` alone. Emitted any
             // earlier, a failing write would produce BOTH terminals and leave the fold's winner
-            // decided by arrival order. The sandbox teardown below emits nothing for the same reason.
+            // decided by arrival order. The release below emits nothing for the same reason.
             await activity.complete();
         }
         finally {
             try {
-                await deps.sandboxClient.teardown(sandbox);
+                await lease.release();
             }
-            catch (teardownErr) {
-                logger.warn("teardown failed (non-fatal)", { executionId, ...logger.errorFields(teardownErr) });
+            catch (releaseErr) {
+                // The owner test of the lease workflow releases a lease that this release missed.
+                logger.warn("release failed (non-fatal)", { executionId, ...logger.errorFields(releaseErr) });
             }
         }
     }

package/dist/tools/ad-hoc-router.d.ts

@@ -1,7 +1,6 @@
 import type { Querier } from "../state/db.js";
 import { type AgentSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
-import type { ResourcePolicy, ResourceSpec } from "../config/resource-limits.js";
 import type { Logger } from "../lib/logger.js";
 import type { AgentRunUsage } from "../loop/metrics.js";
 import { type ChatProvider } from "../providers/types.js";
@@ -22,7 +21,6 @@ export type DroppedPackage = {
 };
 export type AdHocRoute = {
     readonly agentId: string;
-    readonly resources: ResourceSpec;
     readonly rationale: string;
     /** The capability phrase of the chosen agent, when the router copied one that the agent advertises. */
     readonly capability?: string;
@@ -30,13 +28,12 @@ export type AdHocRoute = {
     readonly packages: readonly string[];
     /** Every entry that the validation removed, with the reason for the caveat. */
     readonly droppedPackages: readonly DroppedPackage[];
-    readonly fallbackClass?: "timeout" | "provider_error" | "malformed" | "no_match" | "invalid_agent" | "invalid_resources";
+    readonly fallbackClass?: "timeout" | "provider_error" | "malformed" | "no_match" | "invalid_agent";
 };
 export type AdHocRouterDeps = {
     readonly provider: ChatProvider;
     readonly model: string;
     readonly pool: Querier;
-    readonly resourcePolicy?: ResourcePolicy;
     readonly logger?: Logger;
     /**
      * Test seam that sets an explicit deadline. An explicit value overrides the
@@ -55,8 +52,6 @@ export type AdHocRouterDeps = {
     /** Falls back to the no-op recorder when omitted. */
     readonly usageRecorder?: UsageRecorder;
 };
-export declare function defaultAdHocResources(policy?: ResourcePolicy): ResourceSpec;
-export declare function validAdHocResources(value: unknown, policy?: ResourcePolicy): ResourceSpec | null;
 export declare function routeAdHocRequest(deps: AdHocRouterDeps, input: {
     analysisId: string;
     request: string;

package/dist/tools/ad-hoc-router.js

@@ -10,7 +10,7 @@ import { createNoopLogger } from "../lib/console-logger.js";
 import { toThrowable, unwrapOrThrow } from "../lib/result.js";
 import { parseUnknownRecord } from "../lib/unknown-containers.js";
 import { runLoop } from "../loop/run-loop.js";
-import { packagesSection, resourceEstimationSection } from "../prompts/planner.js";
+import { packagesSection } from "../prompts/planner.js";
 import { effectiveDeadlineMs } from "../providers/types.js";
 import { formatQuery, parseQuery } from "../sandbox/package-identity.js";
 import { loadDataProfileStatus } from "../state/index.js";
@@ -19,50 +19,15 @@ export const AD_HOC_ROUTER_AGENT_ID = "adhoc-router";
 export const AD_HOC_ROUTER_TIMEOUT_MS = 10_000;
 export const AD_HOC_FALLBACK_AGENT_ID = "scientific-executor";
 const SUBMIT_ROUTE_TOOL_ID = "submit_route";
-const resourcesSchema = z.object({
-    cpu: z.number().positive(),
-    memoryGb: z.number().positive(),
-    gpu: z.object({ count: z.number().int().positive() }).optional(),
-});
 const routeSchema = z.object({
     agentId: z.string().optional().describe("The id of one specialist from the eligible catalog, copied exactly."),
     capability: z.string().optional().describe("The one capability phrase of that specialist which this request uses, copied exactly from its capabilities."),
-    resources: resourcesSchema
-        .optional()
-        .describe("The sandbox resources of the step, inside the stated ranges. Omit to take the defaults; a value outside the ranges is replaced by the defaults."),
     rationale: z.string().optional().describe("One or two sentences on why this specialist fits the request. The step agent reads it."),
     packages: z
         .array(z.string())
         .optional()
         .describe("The packages that the scripts of the step import, each as `[python:|r:]<name>[==<version>]`. An empty array is valid."),
 });
-export function defaultAdHocResources(policy) {
-    return policy ? { cpu: Math.min(4, policy.perStep.maxCpu), memoryGb: Math.min(8, policy.perStep.maxMemoryGb) } : { cpu: 4, memoryGb: 8 };
-}
-export function validAdHocResources(value, policy) {
-    const parsed = resourcesSchema.safeParse(value);
-    if (!parsed.success)
-        return null;
-    const r = parsed.data;
-    const maxCpu = policy?.perStep.maxCpu ?? 4;
-    const maxMemoryGb = policy?.perStep.maxMemoryGb ?? 8;
-    const maxGpuCount = policy?.perStep.maxGpuCount ?? 0;
-    if (r.cpu > maxCpu || r.memoryGb > maxMemoryGb || (r.gpu?.count ?? 0) > maxGpuCount)
-        return null;
-    return r;
-}
-function resourceBounds(policy) {
-    const defaults = defaultAdHocResources(policy);
-    if (!policy) {
-        return `CPU range 1..${defaults.cpu}; default ${defaults.cpu}. Memory range 1..${defaults.memoryGb} GB; default ${defaults.memoryGb}. GPU range 0..0.`;
-    }
-    const { perStep } = policy;
-    return [
-        `CPU range ${Math.min(1, perStep.maxCpu)}..${perStep.maxCpu}; default ${defaults.cpu}.`,
-        `Memory range ${Math.min(1, perStep.maxMemoryGb)}..${perStep.maxMemoryGb} GB; default ${defaults.memoryGb}.`,
-        `GPU range 0..${perStep.maxGpuCount}; omit gpu unless required.`,
-    ].join(" ");
-}
 async function profileOrientation(pool, analysisId, logger) {
     try {
         const status = unwrapOrThrow(await loadDataProfileStatus(pool, analysisId));
@@ -85,8 +50,7 @@ function suggestedSpelling(rows) {
 }
 /**
  * Validate the package entries of a route on their own axis: a bad entry costs
- * that entry and nothing else, because the specialist and the resources are
- * sound without it.
+ * that entry and nothing else, because the specialist is sound without it.
  *
  * A guess of a model reaches here, and no person reviewed it. Thus a name that
  * the pool does not hold leaves the step with a caveat, where the same name in
@@ -159,7 +123,7 @@ async function routePackages(raw, resolve, logger) {
 function routeTool() {
     return defineTool({
         id: SUBMIT_ROUTE_TOOL_ID,
-        description: "Submit the single specialist, the resource recommendation, and the packages of the step. This is the only valid response.",
+        description: "Submit the single specialist and the packages of the step. This is the only valid response.",
         inputSchema: routeSchema,
         describeCall: "none",
         execute: () => Promise.resolve(ok({ recorded: true })),
@@ -180,10 +144,8 @@ export async function routeAdHocRequest(deps, input) {
         const router = {
             id: AD_HOC_ROUTER_AGENT_ID,
             systemPrompt: [
-                "Select exactly one specialist for a targeted one-step analysis, estimate its sandbox resources, and name the packages that the step imports.",
+                "Select exactly one specialist for a targeted one-step analysis, and name the packages that the step imports.",
                 "Choose only from the supplied catalog. Do not create a plan, reject the request, or select scientific-executor.",
-                resourceEstimationSection(deps.resourcePolicy),
-                resourceBounds(deps.resourcePolicy),
                 packagesSection(),
                 "You hold no package census. For a name that both ecosystems hold, the language of the specialist you select and the wording of the request decide the track.",
                 "Respond only by calling submit_route.",
@@ -243,10 +205,6 @@ export async function routeAdHocRequest(deps, input) {
         failure = "no_match";
     if (!failure && !validAgent)
         failure = "invalid_agent";
-    const validResources = validAdHocResources(candidate.resources, deps.resourcePolicy);
-    const resources = validResources ?? defaultAdHocResources(deps.resourcePolicy);
-    if (!validResources && candidate.resources !== undefined && !failure)
-        failure = "invalid_resources";
     const rationale = typeof candidate.rationale === "string" && candidate.rationale.trim()
         ? candidate.rationale.trim()
         : failure
@@ -262,10 +220,9 @@ export async function routeAdHocRequest(deps, input) {
     // most requests use a capability that declares nothing.
     const requestedCapability = typeof candidate.capability === "string" ? candidate.capability.trim() : "";
     const capability = (SANDBOX_AGENT_META[agentId]?.capabilities ?? []).includes(requestedCapability) ? requestedCapability : undefined;
-    logger.info("ad hoc route selected", { agentId, resources, rationale, failure, packages, droppedPackages, capability });
+    logger.info("ad hoc route selected", { agentId, rationale, failure, packages, droppedPackages, capability });
     return {
         agentId,
-        resources,
         rationale,
         packages,
         droppedPackages,

package/dist/tools/bio/comptox.js

@@ -107,7 +107,7 @@ export function createComptoxTool(deps) {
             "products). See `dataset` for what each returns; all four resolve `query` to a DTXSID first.\n" +
             "ACCEPTED IDENTIFIERS, for every dataset: a DTXSID ('DTXSID7020182') used directly, or a CASRN ('80-05-7'), a chemical name " +
             "('bisphenol A') or an InChIKey, each resolved by EXACT match.\n" +
-            "Requires EPA_CCTE_API_KEY — a missing key fails terminally: do NOT retry, tell the user the key needs configuring and proceed without EPA data.\n" +
+            "Requires EPA_CCTE_API_KEY — a missing key fails terminally: do NOT retry; state that the key is not configured, and proceed without EPA data.\n" +
             "found: false means the query did not resolve to a chemical; a present-but-empty section is likewise valid no-data. Do not retry either.\n" +
             "This is environmental/industrial-chemical data: for drug-like compounds prefer PubChem or ChEMBL — dataset 'chemical' returns " +
             "`detail.pubchemCid` to bridge back.",

package/dist/tools/bio/drug-gene-interactions.js

@@ -115,7 +115,7 @@ export function createDrugGeneInteractionsTool(deps) {
             "Verbose fields (`includeAttributes`, `includeDrugRecord`) are off by default — both cost a lot of context and are rarely what the question needs.\n" +
             "`perSource` gives the outcome of each corpus, and a conclusion that an interaction is unknown rests on it: 'no_data' means that corpus " +
             "has nothing; 'unavailable' means it could " +
-            "not be reached (a missing DRUGBANK_API_KEY lands here — tell the user and proceed with DGIdb). A `found: false` entry means the identifier " +
+            "not be reached (a missing DRUGBANK_API_KEY lands here — state that the key is missing, and proceed with DGIdb). A `found: false` entry means the identifier " +
             "is not in DGIdb at all, usually a non-HUGO symbol or a brand name. Neither is worth retrying unchanged.",
         inputSchema,
         describeCall: "none",

package/dist/tools/bio/gene-disease-evidence.js

@@ -167,7 +167,7 @@ export function createGeneDiseaseEvidenceTool(deps) {
             "no_data there ('low density lipoprotein cholesterol measurement' is the label) while the other corpora still answer it.\n" +
             "`perSource` gives the outcome of each corpus, and a conclusion of absence rests on it. 'no_data' means that corpus genuinely has nothing; " +
             "'unavailable' means it " +
-            "could not be reached (a missing DISGENET_API_KEY lands here — tell the user and proceed with the others); 'not_applicable' means that " +
+            "could not be reached (a missing DISGENET_API_KEY lands here — state that the key is missing, and proceed with the others); 'not_applicable' means that " +
             "corpus has no lookup for this queryType. Only 'no_data' is evidence of absence, and none is worth retrying unchanged.",
         inputSchema,
         describeCall: "none",

package/dist/tools/bio/keys.d.ts

@@ -3,7 +3,7 @@ import type { Tool } from "../define-tool.js";
 /**
  * API keys for the external bio/chem data sources. Threaded from the
  * composition root to every place that assembles bio tools (conversation
- * agent, sandbox agents, literature reviewer, analogy reporter). Each key
+ * agent, sandbox agents, run synthesizer, analogy reporter). Each key
  * may be empty when its source is unconfigured — the tool surfaces the
  * resulting auth failure as a normal tool error.
  */

package/dist/tools/bio/pubmed.js

@@ -116,6 +116,36 @@ const inputSchema = z
     message: "maxAuthors and maxMeshTerms apply to action 'details' only",
     path: ["action"],
 });
+const ArticleSummarySchema = z.object({ pmid: z.string(), title: z.string(), journal: z.string(), year: z.string(), authors: z.string() });
+const ArticleSchema = z.object({
+    pmid: z.string(),
+    title: z.string(),
+    abstract: z.string(),
+    authors: z.array(z.string()),
+    authorCount: z.number(),
+    journal: z.string(),
+    year: z.string(),
+    doi: z.string(),
+    meshTerms: z.array(z.string()),
+    meshTermCount: z.number(),
+    pmcId: z.string().nullable(),
+});
+const outputSchema = z.union([
+    z.object({ totalFound: z.number(), results: z.array(ArticleSummarySchema) }).describe("action 'search'"),
+    z.object({ articles: z.array(ArticleSchema), notFound: z.array(z.string()) }).describe("action 'details'"),
+    z.object({ pmcId: z.string(), available: z.literal(false) }).describe("action 'fulltext', not open access"),
+    z
+        .object({
+        pmcId: z.string(),
+        available: z.literal(true),
+        fullText: z.string(),
+        outline: z.array(z.object({ heading: z.string(), chars: z.number(), included: z.boolean() })),
+        totalChars: z.number(),
+        returnedChars: z.number(),
+        truncated: z.boolean(),
+    })
+        .describe("action 'fulltext'"),
+]);
 export function createPubMedTool(deps) {
     return defineTool({
         id: "pubmed",
@@ -132,6 +162,7 @@ export function createPubMedTool(deps) {
             "An empty result set and available: false are expected outcomes, not errors — an article with no PMC record simply has no open full text. " +
             "Report it and continue, do not retry it.",
         inputSchema,
+        outputSchema,
         // One tool, three jobs. The action alone would still render three
         // different searches identically, so each action names its own subject:
         // the query, how many articles, or which article.