@inflexa-ai/harness 0.46.2 → 0.47.0

package/dist/report-model/production-resolver.js

@@ -5,13 +5,13 @@
  * The realization holds three layers. Layer one is identity: membership through `snapshotEntry`, and a
  * streamed hash compare with `computeSha256File`. A hash mismatch fails before any parse. Layer two is
  * the host fast path: an in-process parse of a CSV, a TSV, a JSON, or a parquet file at or under the cap.
- * Layer three is the fall-through: an over-cap file or a host parse fault goes to the extraction arm. On any
- * doubt the read falls through, thus correctness never depends on the host parser. An extension that names
- * no tabular format refuses here, because the host decides the format for both arms.
+ * Layer three is the fall-through: an over-cap file or a host parse fault fails as `extraction-unavailable`.
+ * On any doubt the read falls through, thus the host parser never gives a partial or guessed answer. An
+ * extension that names no tabular format refuses the same way.
  *
  * A read of the bytes is the expensive part, thus an optional `ArtifactReadCache` outlives one resolver. It
- * holds the streamed hash and the extracted rows against a stat signature. Two tool calls of one analysis
- * share one cache, and each call still binds its own extraction arm with its own auth.
+ * holds the streamed hash and the parsed rows against a stat signature. Two tool calls of one analysis
+ * share one cache.
  *
  * The realization calls the shared assert functions in `assert-rules.ts`, and it mirrors the locator walk
  * and the reason choices of `fixture-resolver.ts`. Thus one semantics exists, and the fixture stays the
@@ -22,7 +22,6 @@ import { readFile, stat } from "node:fs/promises";
 import { extname } from "node:path";
 import { parquetReadObjects } from "hyparquet";
 import { z } from "zod";
-import { isWorkflowCancellation } from "../runtime/dbos.js";
 import { allWithConcurrency } from "../lib/async-utils.js";
 import { computeSha256File } from "../lib/fs-helpers.js";
 import { parseJsonAs } from "../lib/parse-json.js";
@@ -92,6 +91,10 @@ export function createArtifactReadStore() {
         },
     };
 }
+/** The cells of a fall-through. No reader outside the host exists, thus the reference fails as `extraction-unavailable`. */
+function fallThroughCells(path, hostDetail) {
+    return { kind: "unavailable", detail: `the host read of the file at ${path} stopped because ${hostDetail}, and no other reader exists` };
+}
 /** Build an `Err` that carries the unresolved reference. The `detail` key is present only when there is a detail to carry. */
 function fail(reference, reason, detail) {
     const failure = detail !== undefined ? { reference, reason, detail } : { reference, reason };
@@ -104,10 +107,9 @@ function describeReference(reference) {
 /**
  * Map a file extension to the format that the host arm reads. An unknown extension gives back `undefined`.
  *
- * This is the one format decision of the report path. The extraction request carries the answer, thus the
- * sandbox arm never repeats the mapping and the two arms hold no second table between them.
+ * This is the one format decision of the report path.
  */
-function detectFormat(path) {
+export function detectFormat(path) {
     switch (extname(path).toLowerCase()) {
         case ".csv":
             return "csv";
@@ -130,8 +132,7 @@ function detectFormat(path) {
  * where the caller detects the loss.
  *
  * A non-finite number is not a cell either. A parquet float column holds a `NaN` or an `Infinity`, thus the
- * coercion drops it and the row omits the key. The extraction script (`tasks/extract-values-script.ts`)
- * drops the same value to `None`, thus the host arm and the sandbox arm read the same bytes the same way.
+ * coercion drops it and the row omits the key.
  */
 export function coerceCell(value) {
     if (value === null || value === undefined) {
@@ -339,10 +340,7 @@ async function parseParquet(bytes) {
 }
 /**
  * Read the cells of one artifact through the host fast path. An over-cap file and a parse fault each give
- * back a fall-through, thus the arm reads them out of process.
- *
- * An extension that names no tabular format stops here. The arm reads a file by a decided format, and no
- * format is decided, thus the arm has nothing to obey and the read is unavailable.
+ * back a fall-through. An extension that names no tabular format stops here.
  */
 async function hostReadCells(cap, path, identity) {
     const format = detectFormat(path);
@@ -350,26 +348,33 @@ async function hostReadCells(cap, path, identity) {
         return { kind: "unsupported-format", detail: `the file at ${path} has no supported tabular format, thus no reader is decided for it` };
     }
     if (identity.size > cap) {
-        return { kind: "fall-through", format, detail: `the file size of ${identity.size} bytes is over the ${cap}-byte cap` };
+        return { kind: "fall-through", detail: `the file size of ${identity.size} bytes is over the ${cap}-byte cap` };
     }
     let bytes;
     try {
         bytes = await readFile(identity.absolute);
     }
     catch {
-        return { kind: "fall-through", format, detail: "the file could not be read" };
-    }
-    if (format === "parquet") {
-        const rows = await parseParquet(bytes);
-        return rows === undefined ? { kind: "fall-through", format, detail: "the parquet read did not succeed" } : { kind: "rows", rows };
+        return { kind: "fall-through", detail: "the file could not be read" };
     }
+    const rows = await parseTable(format, bytes);
+    return rows === undefined ? { kind: "fall-through", detail: PARSE_FAULT_DETAIL[format] } : { kind: "rows", rows };
+}
+/** The detail of a parse fault, for each format. */
+const PARSE_FAULT_DETAIL = {
+    csv: "the delimited parse did not succeed",
+    tsv: "the delimited parse did not succeed",
+    json: "the JSON parse did not succeed",
+    parquet: "the parquet read did not succeed",
+};
+/** Parse the bytes of one table in a decided format. A parse fault gives back `undefined`. */
+export async function parseTable(format, bytes) {
+    if (format === "parquet")
+        return parseParquet(bytes);
     const text = bytes.toString("utf8");
-    if (format === "json") {
-        const rows = parseJsonTable(text);
-        return rows === undefined ? { kind: "fall-through", format, detail: "the JSON parse did not succeed" } : { kind: "rows", rows };
-    }
-    const rows = parseDelimited(text, format === "tsv" ? "\t" : ",");
-    return rows === undefined ? { kind: "fall-through", format, detail: "the delimited parse did not succeed" } : { kind: "rows", rows };
+    if (format === "json")
+        return parseJsonTable(text);
+    return parseDelimited(text, format === "tsv" ? "\t" : ",");
 }
 /**
  * Compute the identity of one artifact: membership, containment, and the on-disk hash.
@@ -417,58 +422,6 @@ async function computeIdentity(workspaceRoot, analysisId, path, snapshot, readCa
     readCache?.set(resolved.absolute, { signature, hash: onDiskHash });
     return { kind: "ready", onDiskHash, fileType: entry.fileType, absolute: resolved.absolute, size, signature };
 }
-/**
- * Resolve each fall-through artifact through the extraction arm. One call covers the whole batch. An
- * absent arm gives back `unavailable`, and the detail names the absent arm. An arm that gives no answer
- * for a path gives back `unreadable`.
- */
-async function extractFallThrough(arm, requests) {
-    const out = new Map();
-    if (requests.length === 0) {
-        return out;
-    }
-    if (arm === undefined) {
-        for (const request of requests) {
-            out.set(request.path, {
-                kind: "unavailable",
-                detail: `the extraction arm is not wired, and the file at ${request.path} needs it because ${request.hostDetail}`,
-            });
-        }
-        return out;
-    }
-    let answered;
-    try {
-        answered = await arm.extract(requests.map((request) => ({ path: request.path, hash: request.hash, format: request.format })));
-    }
-    catch (cause) {
-        // The arm speaks the throw protocol for a genuine infrastructure fault. This boundary turns the
-        // throw into a value, thus each reference on the batch reads a failure as data. A cancel of the
-        // workflow is not a fault of the read, thus it leaves to DBOS with no change.
-        if (isWorkflowCancellation(cause))
-            throw cause;
-        for (const request of requests) {
-            out.set(request.path, { kind: "unreadable", detail: `the extraction arm did not read the file at ${request.path}` });
-        }
-        return out;
-    }
-    if (answered.isErr()) {
-        for (const request of requests) {
-            out.set(request.path, {
-                kind: "unavailable",
-                detail: `the host refused the sandbox (${answered.error.reason}), thus the file at ${request.path} was not read`,
-            });
-        }
-        return out;
-    }
-    const answers = answered.value;
-    for (const request of requests) {
-        const answer = answers.get(request.path);
-        out.set(request.path, answer === undefined
-            ? { kind: "unreadable", detail: `the extraction arm did not read the file at ${request.path}` }
-            : { kind: "rows", rows: answer.rows });
-    }
-    return out;
-}
 /**
  * Give back the rows that an earlier pass read for these exact bytes, or `undefined` when nothing shared
  * them. The signature compare is the whole guard: a file that changed on disk holds a different signature,
@@ -479,8 +432,8 @@ function sharedRows(readCache, identity) {
     return held !== undefined && held.signature === identity.signature && held.rows !== undefined ? held.rows : undefined;
 }
 /**
- * Share the rows of one clean read, thus the next pass over the same bytes starts no second container and
- * parses nothing again. A failed read is transient, thus only rows enter the cache.
+ * Share the rows of one clean read, thus the next pass over the same bytes parses nothing again. A failed
+ * read is transient, thus only rows enter the cache.
  */
 function shareRows(readCache, identity, rows) {
     readCache?.set(identity.absolute, { signature: identity.signature, hash: identity.onDiskHash, rows });
@@ -500,7 +453,7 @@ function accessesOf(reference) {
     }
 }
 /**
- * Make the production resolver over the workspace root and the optional extraction arm.
+ * Make the production resolver over the workspace root.
  *
  * The resolver holds a per-pass cache. `prepare` groups the references by artifact, reads each file one
  * time, and fills the cache. `resolve` then answers from the cache. A `resolve` with no prior `prepare`
@@ -508,7 +461,7 @@ function accessesOf(reference) {
  * artifact on both paths, and never one read for each reference.
  */
 export function createProductionResolver(deps) {
-    const { workspaceRoot, analysisId, extractionArm, readCache } = deps;
+    const { workspaceRoot, analysisId, readCache } = deps;
     const cap = deps.cap ?? DEFAULT_CAP_BYTES;
     // The per-pass caches. `prepare` clears and refills them, thus a later pass reads the artifacts again.
     const idCache = new Map();
@@ -528,8 +481,8 @@ export function createProductionResolver(deps) {
     }
     /**
      * Give back the cells of one path, from the cache after a prepare, or by a fresh read. A fresh read
-     * runs the host fast path, and it resolves a fall-through through the arm as a batch of one. The
-     * outcome enters the cache, thus a second reference at one path opens no second batch.
+     * runs the host fast path. The outcome enters the cache, thus a second reference at one path reads
+     * nothing again.
      */
     async function getCells(path, identity) {
         const cached = cellsCache.get(path);
@@ -549,18 +502,9 @@ export function createProductionResolver(deps) {
             cellsCache.set(path, parsed);
             return parsed;
         }
-        if (read.kind === "unsupported-format") {
-            const unavailable = { kind: "unavailable", detail: read.detail };
-            cellsCache.set(path, unavailable);
-            return unavailable;
-        }
-        const resolved = await extractFallThrough(extractionArm, [{ path, hash: identity.onDiskHash, format: read.format, hostDetail: read.detail }]);
-        const cells = resolved.get(path) ?? { kind: "unreadable", detail: `the extraction arm did not read the file at ${path}` };
-        if (cells.kind === "rows") {
-            shareRows(readCache, identity, cells.rows);
-        }
-        cellsCache.set(path, cells);
-        return cells;
+        const unavailable = read.kind === "unsupported-format" ? { kind: "unavailable", detail: read.detail } : fallThroughCells(path, read.detail);
+        cellsCache.set(path, unavailable);
+        return unavailable;
     }
     /**
      * The identity gate that a cell-reading reference passes before a read of cells.
@@ -788,7 +732,7 @@ export function createProductionResolver(deps) {
             }
         }
         // An earlier pass over these exact bytes already paid for the rows. Take them, thus the second pass
-        // of one analysis parses nothing again and starts no second container.
+        // of one analysis parses nothing again.
         const pending = [];
         for (const target of cellTargets) {
             const shared = sharedRows(readCache, target.identity);
@@ -800,10 +744,6 @@ export function createProductionResolver(deps) {
             }
         }
         const reads = await allWithConcurrency(pending.map((target) => async () => ({ target, read: await hostReadCells(cap, target.path, target.identity) })), PREPARE_CONCURRENCY);
-        // Split the clean reads from the fall-throughs, then resolve every fall-through in one arm call. An
-        // unsupported format reaches no arm, because no reader is decided for it.
-        const fallThrough = [];
-        const identityByPath = new Map();
         for (const { target, read } of reads) {
             if (read.kind === "rows") {
                 cellsCache.set(target.path, { kind: "rows", rows: read.rows });
@@ -813,16 +753,7 @@ export function createProductionResolver(deps) {
                 cellsCache.set(target.path, { kind: "unavailable", detail: read.detail });
             }
             else {
-                identityByPath.set(target.path, target.identity);
-                fallThrough.push({ path: target.path, hash: target.identity.onDiskHash, format: read.format, hostDetail: read.detail });
-            }
-        }
-        const resolved = await extractFallThrough(extractionArm, fallThrough);
-        for (const [path, cells] of resolved) {
-            cellsCache.set(path, cells);
-            const identity = identityByPath.get(path);
-            if (cells.kind === "rows" && identity !== undefined) {
-                shareRows(readCache, identity, cells.rows);
+                cellsCache.set(target.path, fallThroughCells(target.path, read.detail));
             }
         }
     }

package/dist/report-render/chart-export.d.ts

@@ -46,6 +46,15 @@ export declare function rendererApi(api: Echarts.CustomSeriesRenderItemAPI): Ren
  * behind.
  */
 export declare function renderChartSvg(echarts: ChartRuntime, option: EchartOption, size: ChartExportSize): Result<string, string>;
+/**
+ * The count of coordinates that one option draws, summed over its series.
+ *
+ * The count bounds the export. A cloud of many thousands of points gives an SVG of many megabytes, two times,
+ * thus the page builds the SVG of such a chart on a click, with the points as one raster layer. An empty slot draws nothing, thus it counts nothing. A radar
+ * polygon draws one coordinate for each indicator, and a violin outline draws two vertices for each grid
+ * point, thus each counts every coordinate that it draws.
+ */
+export declare function plottedPoints(option: EchartOption): number;
 /**
  * The two SVG files of one chart, or `undefined` for a chart past the export bound.
  *

package/dist/report-render/chart-export.js

@@ -138,7 +138,7 @@ function finishedSvg(svg, size) {
  * polygon draws one coordinate for each indicator, and a violin outline draws two vertices for each grid
  * point, thus each counts every coordinate that it draws.
  */
-function plottedPoints(option) {
+export function plottedPoints(option) {
     const series = option.series;
     if (!Array.isArray(series))
         return 0;

package/dist/report-render/views/chart-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The chart card markup.
  *

package/dist/report-render/views/chart-view.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The chart card markup.
  *

package/dist/report-render/views/lineage.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The lineage keys of a grounded block, and the control that opens the chain of one key.
  *

package/dist/report-render/views/page-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The page assembly: the hero, the bands, the appendix band, and the footer.
  *

package/dist/report-render/views/page-view.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The page assembly: the hero, the bands, the appendix band, and the footer.
  *

package/dist/report-render/views/prose.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
  *

package/dist/report-render/views/prose.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
  *

package/dist/report-render/views/references-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The reference markup: the one evidence marker, and the one appendix list under it.
  *

package/dist/report-render/views/values.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The value markup: the metric card, the data table, the figure, and the citation card.
  *

package/dist/report-render/views/values.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The value markup: the metric card, the data table, the figure, and the citation card.
  *

package/dist/runtime/assemble.d.ts

@@ -19,6 +19,7 @@ import { type ConversationAgentDeps } from "../agents/conversation-agent.js";
 import { type ApprovePlanInput, type ApprovePlanRefusal, type PlanApproval } from "../app/approve-plan.js";
 import { type ChatTurns } from "../app/chat-turn-workflow.js";
 import { type WorkSurface } from "../app/work.js";
+import { type RunCanceler } from "../execution/run-canceler.js";
 import { type ReportSessionRuntime } from "../app/report-session-runtime.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -27,6 +28,7 @@ import { type ChromeConfig } from "../lib/chrome.js";
 import { type AcquireEyes } from "../lib/eyes.js";
 import type { ThreadType } from "../memory/thread-store.js";
 import { type ExecuteAnalysisDeps, type ExecuteAnalysisInput, type ExecuteAnalysisResult } from "../workflows/execute-analysis.js";
+import type { SandboxClient } from "../sandbox/client.js";
 import { type SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "../workflows/sandbox-step.js";
 import { type DataProfileDeps, type DataProfileWorkflowInput } from "../tasks/data-profile.js";
 import { type CitationResolverConfig } from "../citations/resolve.js";
@@ -56,12 +58,19 @@ export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxSt
  * the same memory that the conversation agent writes.
  */
 export type CoreWorkflowDeps = {
-    readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "runAuthorizer">;
-    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "literatureReviewer" | "toolOutputStore" | "workingMemory"> & {
-        /** API keys for the bio/chem tools of the literature reviewer of the synthesis. */
+    readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "runAuthorizer" | "leases">;
+    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "synthesisLookups" | "toolOutputStore" | "workingMemory" | "workspaceFs"> & {
+        /** API keys for the bio/chem tools of the lookups of the synthesis. */
         readonly bioKeys: BioToolKeys;
     };
-    readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore">;
+    readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore" | "leases">;
+};
+/** The sandboxes of the runtime. The assembly builds the one sandbox module over the client. */
+export type CoreSandboxDeps = {
+    /** The backend client that the embedder made. Only the sandbox module calls it. */
+    readonly client: SandboxClient;
+    /** How long a lease can go unused before it loses its machine. Absent: 15 minutes. */
+    readonly idlePeriodMs?: number;
 };
 /** The registered, callable workflow handles. */
 export type RegisteredWorkflows = {
@@ -86,7 +95,7 @@ export type RegisteredWorkflows = {
  * chrome config. A caller that bound the eyes here would give the conversation
  * agent a seam that the report agent never sees.
  */
-export type ConversationAssemblyDeps = Omit<ConversationAgentDeps, "executeAnalysisWorkflow" | "resourcePolicy" | "usageRecorder" | "citationResolver" | "anchorReportSession" | "eyes" | "toolOutputStore" | "registerSubAgent">;
+export type ConversationAssemblyDeps = Omit<ConversationAgentDeps, "executeAnalysisWorkflow" | "usageRecorder" | "citationResolver" | "anchorReportSession" | "eyes" | "toolOutputStore" | "registerSubAgent">;
 /**
  * What binds one reference resolver: the analysis whose pinned artifacts it reads, and the identity and the
  * auth of the tool call that reads them. A resolver serves one analysis, thus the report tools build one for
@@ -105,9 +114,9 @@ export type MakeReportReferenceResolver = (scope: ReportResolverScope) => Promis
 export type CoreRuntimeDeps = {
     readonly conversation: ConversationAssemblyDeps;
     readonly workflows: CoreWorkflowDeps;
+    readonly sandbox: CoreSandboxDeps;
     /**
-     * Host resource policy — per-step ceilings and machine budget. One supply
-     * point for planner/routing guidance and workflow-input budget snapshots.
+     * Host resource policy — the per-step ceilings and the budget of the sandbox lease grant.
      */
     readonly resourcePolicy?: ResourcePolicy;
     /**
@@ -121,7 +130,7 @@ export type CoreRuntimeDeps = {
     readonly citationResolverConfig?: CitationResolverConfig;
     /**
      * The byte cap on the in-process host read of a report reference. A file over the
-     * cap falls through to the extraction arm. Absent, the resolver uses its 16 MiB
+     * cap falls through, and its reference fails as `extraction-unavailable`. Absent, the resolver uses its 16 MiB
      * default. The embedder tunes it here, thus a host changes it with no harness change.
      */
     readonly reportHostReadCapBytes?: number;
@@ -129,7 +138,7 @@ export type CoreRuntimeDeps = {
      * The report reference resolver of an embedder. A managed host reads its pinned
      * artifacts from its own store, thus it binds a realization of the seam here and the
      * report tools resolve through it. Absent, the harness wires the production resolver
-     * over the workspace tree and the extraction arm, which is the whole OSS path. A bound
+     * over the workspace tree, which is the whole OSS path. A bound
      * factory replaces that wiring, thus `reportHostReadCapBytes` then governs nothing.
      */
     readonly makeReportReferenceResolver?: MakeReportReferenceResolver;
@@ -263,6 +272,8 @@ export type CoreRuntime = {
      * ends one work in each state, and `resume` and `hold` reach the waits of one work. Only a client resumes paused work.
      */
     readonly work: WorkSurface;
+    /** The run canceler of `work`. It also ends the sandbox leases of the canceled workflows at once. */
+    readonly runCanceler: RunCanceler;
     /**
      * Approve a stored plan by its id and start its run with no model call. It runs over the deps that
      * reach the `execute_analysis` tool of the conversation agent, thus the approval and the tool launch

package/dist/runtime/assemble.js

@@ -28,9 +28,11 @@ import { workPause } from "../workflows/pause.js";
 import { hasBrowserUrl } from "../lib/chrome.js";
 import { createStaticEyes } from "../lib/eyes.js";
 import { registerExecuteAnalysis } from "../workflows/execute-analysis.js";
+import { createSandboxLeases } from "../sandbox/leases.js";
+import { createNoopLogger } from "../lib/console-logger.js";
+import { dbosClientFor } from "../execution/dbos-workflow-purger.js";
 import { registerSandboxStep } from "../workflows/sandbox-step.js";
 import { registerDataProfileWorkflow, stopDataProfile } from "../tasks/data-profile.js";
-import { createExtractionArm, runExtraction } from "../tasks/extract-values.js";
 import { createCitationResolver } from "../citations/resolve.js";
 import { createThreadStore } from "../memory/thread-store.js";
 import { createWorkingMemory } from "../memory/working-memory.js";
@@ -38,7 +40,7 @@ import { createArtifactReadStore, createProductionResolver } from "../report-mod
 import { createReportVersionStore } from "../state/report-versions.js";
 import { createToolOutputStore } from "../state/tool-outputs.js";
 import { createAskGateway } from "../tools/approval/gateway.js";
-import { createLiteratureReviewerTool } from "../tools/research/literature-reviewer.js";
+import { createSynthesisLookupTools } from "../tools/research/synthesis-lookups.js";
 const _assertDomainError = true;
 /**
  * Wrap a type→agent registry as the resolution surface. Held apart from
@@ -83,7 +85,7 @@ export function resolveCompositionEyes(seam, chrome) {
     return undefined;
 }
 export function assembleCoreRuntime(deps) {
-    const { conversation, workflows: wf, resourcePolicy } = deps;
+    const { conversation, workflows: wf } = deps;
     const usageRecorder = deps.usageRecorder ?? createNoopUsageRecorder();
     const citationResolver = createCitationResolver({
         ...deps.citationResolverConfig,
@@ -102,8 +104,21 @@ export function assembleCoreRuntime(deps) {
         logger: conversation.logger,
     }).afterFailure;
     const registerPausingSubAgent = (name, body) => registerSubAgent(name, body, subAgentPauses);
+    // One sandbox module for each runtime: one budget, one lease workflow, and one reconciler.
+    const leases = createSandboxLeases({
+        pool: conversation.pool,
+        client: deps.sandbox.client,
+        resourcePolicy: deps.resourcePolicy,
+        resolveWorkspaceRoot: conversation.resolveWorkspaceRoot,
+        runAuthorizer: conversation.runAuthorizer,
+        idlePeriodMs: deps.sandbox.idlePeriodMs,
+        pauseRetryDelaysMs,
+        logger: conversation.logger,
+        dbosClient: () => dbosClientFor(conversation.pool, conversation.logger ?? createNoopLogger()),
+    });
     const sandboxStep = registerSandboxStep({
         ...wf.sandboxStep,
+        leases,
         citationResolver,
         usageRecorder,
         toolOutputStore,
@@ -111,24 +126,18 @@ export function assembleCoreRuntime(deps) {
         runAuthorizer: conversation.runAuthorizer,
     });
     const { bioKeys: synthesisBioKeys, ...executeAnalysisDeps } = wf.buildExecuteAnalysis(sandboxStep);
-    const literatureReviewer = createLiteratureReviewerTool({
-        provider: executeAnalysisDeps.provider,
-        model: executeAnalysisDeps.synthesisModel,
-        bioKeys: synthesisBioKeys,
-        citationResolver,
-        usageRecorder,
-        toolOutputStore,
-        logger: executeAnalysisDeps.logger,
-    }, registerPausingSubAgent);
+    const synthesisLookups = createSynthesisLookupTools({ bioKeys: synthesisBioKeys, citationResolver, logger: executeAnalysisDeps.logger });
     const executeAnalysis = registerExecuteAnalysis({
         ...executeAnalysisDeps,
-        literatureReviewer,
+        synthesisLookups,
+        scriptRuntime: conversation.scriptRuntime,
+        workspaceFs: conversation.workspaceFs,
         usageRecorder,
         toolOutputStore,
         workingMemory: createWorkingMemory(conversation.pool),
         pauseRetryDelaysMs,
     });
-    const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, usageRecorder, toolOutputStore, pauseRetryDelaysMs });
+    const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, leases, usageRecorder, toolOutputStore, pauseRetryDelaysMs });
     // The session runtime binds the per-session state to the thread behind the
     // tool boundary, thus one instance serves every report thread. It comes before
     // the conversation agent, because `start_report_session` takes its anchor
@@ -147,7 +156,6 @@ export function assembleCoreRuntime(deps) {
         ...conversation,
         executeAnalysisWorkflow: executeAnalysis,
         anchorReportSession: reportSession.ensureSessionState.bind(reportSession),
-        resourcePolicy,
         usageRecorder,
         toolOutputStore,
         citationResolver,
@@ -164,21 +172,16 @@ export function assembleCoreRuntime(deps) {
     const reportThreads = createThreadStore(conversation.pool);
     // The read cache of the production report path, one for each recent analysis. A preview
     // and the record that follows it are two tool calls over one draft, thus they meet the
-    // same artifacts. The store carries the streamed hash and the extracted rows between
-    // them, and each resolver still binds its own extraction arm below. Thus the auth of a
-    // call never outlives the call, and one unchanged file costs one hash and one container.
+    // same artifacts. The store carries the streamed hash and the parsed rows between them,
+    // thus one unchanged file costs one hash and one parse.
     const reportArtifactReads = createArtifactReadStore();
     // The reference resolver of the report path, and its production wiring. A resolver reads
     // the pinned artifacts of one analysis, thus the factory binds one analysis and one caller
-    // for each tool call. The extraction arm falls through to an extraction pass on the sandbox
-    // rail of the profile for an over-cap file or a host parse fault. The pass runs inside the
-    // step of the tool call. The cap gates the host read, and the resolver defaults it to 16 MiB.
+    // for each tool call. The cap gates the host read, and the resolver defaults it to 16 MiB.
     const makeProductionReportResolver = async (scope) => {
-        const arm = createExtractionArm((requests) => runExtraction({ sandboxClient: wf.dataProfile.sandboxClient, logger: wf.dataProfile.logger }, scope, requests));
         return createProductionResolver({
             workspaceRoot: await conversation.resolveWorkspaceRoot(scope.analysisId),
             analysisId: scope.analysisId,
-            extractionArm: arm,
             readCache: reportArtifactReads.forAnalysis(scope.analysisId),
             cap: deps.reportHostReadCapBytes,
         });
@@ -192,13 +195,9 @@ export function assembleCoreRuntime(deps) {
         gateway: reportSession.gateway,
         resolveWorkspaceRoot: conversation.resolveWorkspaceRoot,
         store: reportVersionStore,
+        derivations: reportSession.derivations,
         threads: reportThreads,
         chrome: conversation.chrome,
-        // The derivation tool draws the rail of the value tier: the same sandbox client. Thus a
-        // session derivation and an extraction run on one substrate, and neither one mints a run
-        // of the analysis.
-        derivations: reportSession.derivations,
-        sandboxClient: wf.dataProfile.sandboxClient,
         makeResolver: makeReportResolver,
         eyes,
         resolvePageAsset: deps.resolveReportPageAsset,
@@ -207,6 +206,7 @@ export function assembleCoreRuntime(deps) {
         provenance: deps.provenance,
         logger: conversation.logger,
         toolOutputStore,
+        scriptRuntime: conversation.scriptRuntime,
     });
     // The single registration point for every typed agent. A future thread type's
     // agent plugs in here at assembly with no embedder change. `conversation` is
@@ -232,8 +232,18 @@ export function assembleCoreRuntime(deps) {
         credentialFor: deps.credentialFor,
         pauseRetryDelaysMs,
     });
+    const runCanceler = createRunCanceler({
+        pool: conversation.pool,
+        runCharge: executeAnalysisDeps.runCharge,
+        runAuthorizer: conversation.runAuthorizer,
+        // The end of a canceled run goes where the run engine emits the rest of the run.
+        provenance: executeAnalysisDeps.provenance,
+        logger: conversation.logger,
+        releaseLeasesOf: (workflowIds) => leases.releaseOwnedBy(workflowIds),
+    });
     return {
         agents: agentResolver,
+        runCanceler,
         askGateway,
         chatTurns,
         work: createWork({
@@ -241,15 +251,15 @@ export function assembleCoreRuntime(deps) {
             runAuthorizer: conversation.runAuthorizer,
             logger: conversation.logger,
             stopTurn: (turnId) => chatTurns.stop(turnId),
-            runCanceler: createRunCanceler({
-                pool: conversation.pool,
-                runCharge: executeAnalysisDeps.runCharge,
-                runAuthorizer: conversation.runAuthorizer,
-                // The end of a canceled run goes where the run engine emits the rest of the run.
-                provenance: executeAnalysisDeps.provenance,
-                logger: conversation.logger,
-            }),
-            stopProfile: (analysisId, workflowId) => stopDataProfile({ pool: conversation.pool, logger: conversation.logger, notifyDataProfileSettled: wf.dataProfile.notifyDataProfileSettled }, analysisId, workflowId),
+            runCanceler,
+            stopProfile: async (analysisId, workflowId) => {
+                await stopDataProfile({ pool: conversation.pool, logger: conversation.logger, notifyDataProfileSettled: wf.dataProfile.notifyDataProfileSettled }, analysisId, workflowId);
+                // A canceled body runs no teardown, thus the lease of the profile ends here and not at its owner check.
+                await leases.releaseOwnedBy([workflowId]).catch((failure) => {
+                    const logger = conversation.logger ?? createNoopLogger();
+                    logger.error("the sandbox lease of a stopped profile did not end", { analysisId, ...logger.errorFields(failure) });
+                });
+            },
         }),
         reportSession: { ensureSessionState: reportSession.ensureSessionState.bind(reportSession) },
         workflows: {
@@ -263,7 +273,6 @@ export function assembleCoreRuntime(deps) {
             executeAnalysisWorkflow: executeAnalysis,
             runAuthorizer: conversation.runAuthorizer,
             runLauncher: conversation.runLauncher,
-            resourcePolicy,
             extendAnalysisFarm: conversation.extendAnalysisFarm,
             logger: conversation.logger,
             provenance: deps.provenance,