@inflexa-ai/harness 0.45.1 → 0.46.2

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

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
 /**
  * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
  *
@@ -11,6 +11,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "hono/jsx/jsx-
  */
 import { raw } from "hono/html";
 import { blockMark } from "./block-mark.js";
+import { splitLines } from "../../lib/text.js";
 import { DEFAULT_VIEW_OPTIONS, lineagePlace, lineageStamp } from "./lineage.js";
 import { Marker } from "./references-view.js";
 /** The paragraph class of a text block and a claim block. The paragraph fills the content column. */
@@ -24,20 +25,34 @@ const BRAND_HREF = "https://inflexa.ai/";
  * out, thus a leading or a trailing blank line adds no empty paragraph.
  */
 function splitParagraphs(prose) {
-    const parts = prose.split(/\n[ \t]*\n/);
     const paragraphs = [];
-    for (const part of parts) {
-        const trimmed = part.trim();
-        if (trimmed.length > 0) {
-            paragraphs.push(trimmed);
+    let paragraph = [];
+    for (const line of splitLines(prose)) {
+        if (isBlankLine(line)) {
+            if (paragraph.length > 0)
+                paragraphs.push(paragraph.join("\n").trim());
+            paragraph = [];
+            continue;
         }
+        paragraph.push(line);
     }
+    if (paragraph.length > 0)
+        paragraphs.push(paragraph.join("\n").trim());
     return paragraphs;
 }
+/** A line of spaces and tabs alone. Only those two end a paragraph split. */
+function isBlankLine(line) {
+    for (const char of line) {
+        if (char !== " " && char !== "\t")
+            return false;
+    }
+    return true;
+}
 /**
  * One typed list as list markup. The flag selects the element: an ordered list numbers its items, and an
  * unordered one bullets them. Each item is one inline line, thus no item holds a list of its own.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function TextListView({ list, mark }) {
     const items = list.items.map((item) => _jsx("li", { class: "report-list-item", children: item }));
     return list.ordered ? (_jsx("ol", { class: LIST_CLASS, ...mark, children: items })) : (_jsx("ul", { class: LIST_CLASS, ...mark, children: items }));
@@ -73,7 +88,9 @@ export function renderClaim(block, ledger, view = DEFAULT_VIEW_OPTIONS) {
     // Under the lineage a wrapper holds the paragraphs, thus the wrapper alone carries the mark.
     const mark = view.lineage ? {} : blockMark(block.id);
     const body = paragraphs.length === 0 ? (_jsx("p", { class: PARAGRAPH_CLASS, ...mark, children: markers })) : (_jsx(_Fragment, { children: paragraphs.map((paragraph, index) => (_jsxs("p", { class: PARAGRAPH_CLASS, ...mark, children: [paragraph, index === last ? markers : null] }))) }));
-    return String(view.lineage ? (_jsx("div", { ...blockMark(block.id), ...lineageStamp(view.lineage, block.id, block.bindings), children: body })) : (body));
+    return String(
+    // oxlint-disable-next-line typescript/no-base-to-string -- hono JSXNode.toString() renders these sync element trees to HTML; the rule sees only its declared `string | Promise<string>` return.
+    view.lineage ? (_jsx("div", { ...blockMark(block.id), ...lineageStamp(view.lineage, block.id, block.bindings), children: body })) : (body));
 }
 /** The heading class of a section, by heading level. A heading uses the sans family, never the mono family. */
 function headingClass(level) {
@@ -86,7 +103,7 @@ function headingClass(level) {
  */
 export function renderSection(section, depth, childrenHtml) {
     const level = Math.min(depth + 2, 4);
-    const Heading = `h${level}`;
+    const Heading = level === 2 ? "h2" : level === 3 ? "h3" : "h4";
     return String(_jsxs("section", { id: section.id, class: "report-section", ...blockMark(section.id), children: [_jsx(Heading, { class: headingClass(level), children: section.title }), raw(childrenHtml)] }));
 }
 /**

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

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "hono/jsx/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
 import { citationRecordOf } from "../../report-model/reference-resolver.js";
 import { citationKeyOf } from "../references.js";
 import { LineageControl } from "./lineage.js";
@@ -12,22 +12,27 @@ import { LineageControl } from "./lineage.js";
  * marker that names no place carries no control. The page shows the control only where a stamp gives the
  * script a key to walk.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 export function Marker({ n, lineage }) {
     return (_jsxs("span", { class: "report-marker", children: [_jsx("a", { href: `#ref-${n}`, children: `[${n}]` }), lineage !== undefined ? _jsx(LineageControl, { place: lineage }) : null] }));
 }
 /** The kind label of one reference entry. */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function RefKind({ children }) {
     return _jsx("span", { class: "report-ref-kind", children: children });
 }
 /** A path in a monospace code span. */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function PathCode({ children }) {
     return _jsx("code", { class: "report-ref-path", children: children });
 }
 /** A plain detail such as a locator or an external id. */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function Detail({ children }) {
     return _jsx("span", { class: "report-ref-detail", children: children });
 }
 /** The head of a content hash in a monospace span. */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function HashCode({ children }) {
     return _jsx("code", { class: "report-ref-hash", children: children });
 }
@@ -52,6 +57,7 @@ function hashHead(hash) {
  * The hash head stays the text of the link. Thus the reader reads the same head as before, and the click
  * opens the script itself. A chain with no staged script shows the head alone.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function ScriptLink({ chain }) {
     const head = _jsx(HashCode, { children: hashHead(chain.scriptHash) });
     return chain.scriptSource === undefined ? (head) : (_jsx("a", { class: "report-ref-link", href: chain.scriptSource, children: head }));
@@ -68,6 +74,7 @@ function ScriptLink({ chain }) {
  * host. Each hash head stays beside its link, because the head is what a reader compares against the name of
  * a staged file.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function ChainLine({ chain }) {
     return (_jsxs("div", { class: "report-ref-chain", children: [_jsx(RefKind, { children: "Derived from" }), " ", chain.sources.map((source, index) => (_jsxs(_Fragment, { children: [index > 0 ? " and " : "", _jsx(PathCode, { children: source.path }), " ", _jsx(HashCode, { children: hashHead(source.hash) })] }))), " ", _jsx(Detail, { children: "by script" }), " ", _jsx(ScriptLink, { chain: chain }), chain.outputSource !== undefined ? (_jsxs(_Fragment, { children: [" ", _jsx(Detail, { children: "into" }), " ", _jsx("a", { class: "report-ref-link", href: chain.outputSource, children: _jsx(PathCode, { children: chain.outputSource }) })] })) : null] }));
 }
@@ -99,6 +106,7 @@ function describeLocator(locator) {
  * the reference pins one cell. A derivation entry names its operation and its two inputs, each by path and
  * locator.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function ReferenceBody({ reference }) {
     switch (reference.kind) {
         case "artifact-value":
@@ -117,6 +125,7 @@ function ReferenceBody({ reference }) {
  * A path that no record names renders the body alone, thus a page over pinned artifacts alone reads exactly
  * as it did before the chains existed.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function ArtifactEntry({ reference, chains }) {
     const path = pathOf(reference);
     const chain = path === undefined ? undefined : chains?.get(path);
@@ -130,6 +139,7 @@ function ArtifactEntry({ reference, chains }) {
  * The description sits in the appendix and never on the card. The card sits in the body of the report,
  * where a paragraph about the paper competes with the prose around it.
  */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function CitationEntry({ reference, records }) {
     const key = citationKeyOf(reference);
     const record = citationRecordOf(records, key);
@@ -137,6 +147,7 @@ function CitationEntry({ reference, records }) {
     return (_jsxs(_Fragment, { children: [_jsx(RefKind, { children: "Citation" }), " ", record !== undefined ? (_jsxs(_Fragment, { children: [_jsx("span", { class: "report-cite-source", children: record.citation }), " "] })) : null, _jsx(Detail, { children: key }), description !== undefined ? _jsx("div", { class: "report-cite-description", children: description }) : null] }));
 }
 /** One appendix entry. The kind of the reference selects the shape, and the two shapes share the ladder. */
+// oxlint-disable-next-line typescript/explicit-function-return-type -- hono's JSX ElementType contract demands FunctionComponentResult, which its own jsxDEV factory return (JSXNode) does not satisfy; no writable type names what the body returns, so the inferred JSXNode return stays.
 function ReferenceEntry({ reference, records, chains }) {
     return reference.kind === "citation" ? _jsx(CitationEntry, { reference: reference, records: records }) : _jsx(ArtifactEntry, { reference: reference, chains: chains });
 }

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

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

package/dist/runtime/assemble.d.ts

@@ -17,6 +17,8 @@
 import { type Result, type ResultAsync } from "neverthrow";
 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 ReportSessionRuntime } from "../app/report-session-runtime.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -26,17 +28,15 @@ 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 SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "../workflows/sandbox-step.js";
-import type { Suspension } from "../workflows/suspension.js";
 import { type DataProfileDeps, type DataProfileWorkflowInput } from "../tasks/data-profile.js";
-import { type ExtractValuesResult, type ExtractValuesWorkflowInput } from "../tasks/extract-values.js";
-import type { DeriveTableExecInput } from "../tools/report-session/derive-table.js";
-import type { ExecResult } from "../sandbox/types.js";
 import { type CitationResolverConfig } from "../citations/resolve.js";
 import type { CitationResolver } from "../citations/types.js";
-import type { AuthContext } from "../auth/types.js";
+import type { AuthContext, Identity } from "../auth/types.js";
 import type { ReferenceResolver } from "../report-model/reference-resolver.js";
 import type { ProvenanceSeam } from "../provenance/seam.js";
+import { type AskGateway } from "../tools/approval/gateway.js";
 import type { MakeSessionPagePublisher, ResolvePageAsset, ResolvePageUrl } from "../tools/report-session/index.js";
+import type { BioToolKeys } from "../tools/bio/keys.js";
 /** Registered child sandbox-step callable the parent's child dispatch closes over. */
 export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxStepResult>;
 /**
@@ -55,19 +55,20 @@ export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxSt
  * `executeAnalysis` bag omits `workingMemory`, because the step seeds must read
  * the same memory that the conversation agent writes.
  */
-export interface CoreWorkflowDeps {
-    readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore">;
-    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "workingMemory">;
+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 bioKeys: BioToolKeys;
+    };
     readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore">;
-}
+};
 /** The registered, callable workflow handles. */
-export interface RegisteredWorkflows {
+export type RegisteredWorkflows = {
     readonly executeAnalysis: (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
     readonly sandboxStep: SandboxStepCallable;
     readonly dataProfile: (input: DataProfileWorkflowInput) => Promise<void>;
-    readonly extractValues: (input: ExtractValuesWorkflowInput) => Promise<Result<ExtractValuesResult, Suspension>>;
-    readonly deriveTableExec: (input: DeriveTableExecInput) => Promise<Result<ExecResult, Suspension>>;
-}
+};
 /**
  * Conversation-agent deps minus the workflow callable, the resource policy, the
  * usage recorder, the report-session anchor, the eyes, and the tool output store.
@@ -85,21 +86,23 @@ export interface 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">;
+export type ConversationAssemblyDeps = Omit<ConversationAgentDeps, "executeAnalysisWorkflow" | "resourcePolicy" | "usageRecorder" | "citationResolver" | "anchorReportSession" | "eyes" | "toolOutputStore" | "registerSubAgent">;
 /**
- * What binds one reference resolver: the analysis whose pinned artifacts it reads, and the auth of the tool
- * call that reads them. A resolver serves one analysis, thus the report tools build one for each call.
+ * 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
+ * each call.
  */
-export interface ReportResolverScope {
+export type ReportResolverScope = {
     readonly analysisId: string;
+    readonly identity: Identity;
     readonly auth: AuthContext;
-}
+};
 /**
  * The factory that gives the reference resolver of one report tool call. The harness wires the production
  * realization, and an embedder can bind its own at its composition root.
  */
 export type MakeReportReferenceResolver = (scope: ReportResolverScope) => Promise<ReferenceResolver>;
-export interface CoreRuntimeDeps {
+export type CoreRuntimeDeps = {
     readonly conversation: ConversationAssemblyDeps;
     readonly workflows: CoreWorkflowDeps;
     /**
@@ -185,7 +188,15 @@ export interface CoreRuntimeDeps {
      * which an embedder calls on its own. Thus that composition binds the seam there as well.
      */
     readonly provenance?: ProvenanceSeam;
-}
+    /**
+     * The credential of a chat turn that this process did not open, for example a turn that a recovery runs after a
+     * restart. The workflow input of a turn holds no credential. Absent, or `undefined` for a turn: the turn pauses
+     * with the cause `credential` before its next model call, until a resume gives a credential.
+     */
+    readonly credentialFor?: (turnId: string) => AuthContext | undefined;
+    /** The delays of the timer of an outage, for each kind of work. Absent: the default of the pause. */
+    readonly pauseRetryDelaysMs?: readonly number[];
+};
 /**
  * The refusal a thread type carries no agent yet. `report` is a valid
  * `ThreadType` with no registered agent until its builder plugs in at assembly,
@@ -194,19 +205,19 @@ export interface CoreRuntimeDeps {
  * life, and a bare-`AgentDefinition` return would force every future member to
  * register an agent in the same commit that adds the member.
  */
-export interface UnregisteredThreadType {
+export type UnregisteredThreadType = {
     readonly type: "unregistered_thread_type";
     readonly threadType: ThreadType;
-}
+};
 /**
  * How a thread's type selects the agent that runs its turns. Resolution is a
  * synchronous record lookup, so the channel is plain `Result`, never
  * `ResultAsync`: a registered type resolves to its assembled singleton, an
  * unregistered one refuses on the error channel.
  */
-export interface ThreadAgentResolver {
+export type ThreadAgentResolver = {
     forThread(type: ThreadType): Result<AgentDefinition, UnregisteredThreadType>;
-}
+};
 /**
  * Wrap a type→agent registry as the resolution surface. Held apart from
  * `assembleCoreRuntime` so the resolution contract — a registered type resolves
@@ -219,7 +230,7 @@ export interface ThreadAgentResolver {
  * stay valid across every turn.
  */
 export declare function createThreadAgentResolver(registry: Partial<Record<ThreadType, AgentDefinition>>): ThreadAgentResolver;
-export interface CoreRuntime {
+export type CoreRuntime = {
     /**
      * Thread→agent resolution — the only way to reach an assembled agent by
      * thread type. Holds the singletons this call built; `conversation` resolves
@@ -236,13 +247,29 @@ export interface CoreRuntime {
     readonly reportSession: Pick<ReportSessionRuntime, "ensureSessionState">;
     readonly workflows: RegisteredWorkflows;
     readonly citationResolver: CitationResolver;
+    /**
+     * The tool-approval gateway over the pool of the runtime: the one realization of `ctx.ask`. A host answers,
+     * lists, and sweeps the asks through it.
+     */
+    readonly askGateway: AskGateway;
+    /**
+     * The chat turns of the runtime: `open` starts the workflow of a turn, `read` gives its frames, `stop` ends it,
+     * and `answer` answers one of its asks. The turn makes its model, its usage recorder, and its approval binding
+     * from the runtime, thus a host gives only the session and the user input.
+     */
+    readonly chatTurns: ChatTurns;
+    /**
+     * The durable work of an analysis: `list` gives each active turn, run, and data profile with its waits, `stop`
+     * 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;
     /**
      * 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
      * a plan the same way.
      */
     readonly approvePlan: (input: ApprovePlanInput) => ResultAsync<PlanApproval, ApprovePlanRefusal>;
-}
+};
 /**
  * The eyes of the composition, or none.
  *

package/dist/runtime/assemble.js

@@ -18,21 +18,27 @@ import { err, ok } from "neverthrow";
 import { createConversationAgent } from "../agents/conversation-agent.js";
 import { createReportSessionAgent } from "../agents/report-session-agent.js";
 import { approvePlan } from "../app/approve-plan.js";
+import { registerChatTurns } from "../app/chat-turn-workflow.js";
+import { createWork } from "../app/work.js";
+import { createRunCanceler } from "../execution/run-canceler.js";
 import { createReportSessionRuntime } from "../app/report-session-runtime.js";
 import { createNoopUsageRecorder } from "../billing/noop-usage-recorder.js";
+import { registerSubAgent } from "../loop/sub-agent.js";
+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 { registerSandboxStep } from "../workflows/sandbox-step.js";
-import { registerDataProfileWorkflow } from "../tasks/data-profile.js";
-import { bindExtractionTrigger, createExtractionArm, registerExtractValuesWorkflow, } from "../tasks/extract-values.js";
-import { registerDeriveTableExecWorkflow, triggerDeriveTableExec } from "../tasks/derive-table-exec.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";
 import { createArtifactReadStore, createProductionResolver } from "../report-model/production-resolver.js";
 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";
 const _assertDomainError = true;
 /**
  * Wrap a type→agent registry as the resolution surface. Held apart from
@@ -80,36 +86,49 @@ export function assembleCoreRuntime(deps) {
     const { conversation, workflows: wf, resourcePolicy } = deps;
     const usageRecorder = deps.usageRecorder ?? createNoopUsageRecorder();
     const citationResolver = createCitationResolver({
-        ...(deps.citationResolverConfig ?? {}),
-        ...(deps.citationResolverConfig?.ncbiApiKey !== undefined || conversation.bioKeys.ncbi === undefined ? {} : { ncbiApiKey: conversation.bioKeys.ncbi }),
-        ...(deps.citationResolverConfig?.semanticScholarApiKey !== undefined || conversation.bioKeys.semanticScholar === undefined
-            ? {}
-            : { semanticScholarApiKey: conversation.bioKeys.semanticScholar }),
+        ...deps.citationResolverConfig,
+        ncbiApiKey: deps.citationResolverConfig?.ncbiApiKey ?? conversation.bioKeys.ncbi,
+        semanticScholarApiKey: deps.citationResolverConfig?.semanticScholarApiKey ?? conversation.bioKeys.semanticScholar,
     });
     const toolOutputStore = createToolOutputStore(conversation.pool);
-    const sandboxStep = registerSandboxStep({ ...wf.sandboxStep, citationResolver, usageRecorder, toolOutputStore });
-    const executeAnalysis = registerExecuteAnalysis({
-        ...wf.buildExecuteAnalysis(sandboxStep),
+    const pauseRetryDelaysMs = deps.pauseRetryDelaysMs;
+    // Each child of a sub-agent pauses with the work of its caller, thus a resume of the turn or of the run ends its wait.
+    const subAgentPauses = ({ runSession, ...work }, emit) => workPause({
+        pool: conversation.pool,
+        ...work,
+        emit,
+        retryDelaysMs: pauseRetryDelaysMs,
+        run: runSession === undefined ? undefined : { session: runSession, authorizer: conversation.runAuthorizer },
+        logger: conversation.logger,
+    }).afterFailure;
+    const registerPausingSubAgent = (name, body) => registerSubAgent(name, body, subAgentPauses);
+    const sandboxStep = registerSandboxStep({
+        ...wf.sandboxStep,
         citationResolver,
         usageRecorder,
         toolOutputStore,
-        workingMemory: createWorkingMemory(conversation.pool),
-    });
-    const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, usageRecorder, toolOutputStore });
-    // The extraction workflow shares the profile's sandbox and authorization rails, thus it draws the same
-    // three seams from the profile deps. The report resolver factory binds the extraction arm over this
-    // callable, thus a fall-through report reference reads its file out of process on the profile rails.
-    const extractValues = registerExtractValuesWorkflow({
-        sandboxClient: wf.dataProfile.sandboxClient,
-        runAuthorizer: wf.dataProfile.runAuthorizer,
-        ...(wf.dataProfile.logger ? { logger: wf.dataProfile.logger } : {}),
+        pauseRetryDelaysMs,
+        runAuthorizer: conversation.runAuthorizer,
     });
-    // A session derivation runs its container here and not in the turn. An exec is a durable step of a
-    // workflow, thus the tool starts this workflow and awaits it.
-    const deriveTableExec = registerDeriveTableExecWorkflow({
-        sandboxClient: wf.dataProfile.sandboxClient,
-        ...(wf.dataProfile.logger ? { logger: wf.dataProfile.logger } : {}),
+    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 executeAnalysis = registerExecuteAnalysis({
+        ...executeAnalysisDeps,
+        literatureReviewer,
+        usageRecorder,
+        toolOutputStore,
+        workingMemory: createWorkingMemory(conversation.pool),
+        pauseRetryDelaysMs,
     });
+    const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, 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
@@ -119,7 +138,7 @@ export function assembleCoreRuntime(deps) {
     const reportSession = createReportSessionRuntime({
         pool: conversation.pool,
         resolveWorkspaceRoot: conversation.resolveWorkspaceRoot,
-        ...(conversation.logger ? { logger: conversation.logger } : {}),
+        logger: conversation.logger,
     });
     // The eyes of the composition resolve one time here. Thus the agent that looks at a page and
     // the tool that starts a session read one answer. No tool reads the precedence again.
@@ -127,20 +146,21 @@ export function assembleCoreRuntime(deps) {
     const conversationAgent = createConversationAgent({
         ...conversation,
         executeAnalysisWorkflow: executeAnalysis,
-        anchorReportSession: reportSession.ensureSessionState,
+        anchorReportSession: reportSession.ensureSessionState.bind(reportSession),
         resourcePolicy,
         usageRecorder,
         toolOutputStore,
         citationResolver,
-        ...(eyes ? { eyes } : {}),
+        eyes,
         // The start tool passes it to the spawn, which emits the creation of a
         // report session. The same seam reaches the report agent below.
-        ...(deps.provenance ? { provenance: deps.provenance } : {}),
+        provenance: deps.provenance,
+        registerSubAgent: registerPausingSubAgent,
     });
     // The report agent is a singleton over the conversation deps, the same way the
     // session runtime is. Its preview tool writes the page into the analysis tree
     // and returns the path, thus the page write reaches no host seam.
-    const reportVersionStore = createReportVersionStore({ pool: conversation.pool, ...(conversation.logger ? { logger: conversation.logger } : {}) });
+    const reportVersionStore = createReportVersionStore({ pool: conversation.pool, logger: conversation.logger });
     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
@@ -149,18 +169,18 @@ export function assembleCoreRuntime(deps) {
     // call never outlives the call, and one unchanged file costs one hash and one container.
     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 auth
-    // for each tool call. The extraction arm falls through to the registered extract-values
-    // callable for an over-cap file or a host parse fault. The cap gates the host read, and
-    // the resolver defaults it to 16 MiB.
+    // 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.
     const makeProductionReportResolver = async (scope) => {
-        const arm = createExtractionArm(bindExtractionTrigger({ runAuthorizer: conversation.runAuthorizer, workflow: extractValues }, { auth: scope.auth, analysisId: scope.analysisId }));
+        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),
-            ...(deps.reportHostReadCapBytes !== undefined ? { cap: deps.reportHostReadCapBytes } : {}),
+            cap: deps.reportHostReadCapBytes,
         });
     };
     const makeReportResolver = deps.makeReportReferenceResolver ?? makeProductionReportResolver;
@@ -174,19 +194,18 @@ export function assembleCoreRuntime(deps) {
         store: reportVersionStore,
         threads: reportThreads,
         chrome: conversation.chrome,
-        // The derivation tool draws the rails of the value tier: the same sandbox client
-        // and the same run authorizer. Thus a session derivation and an extraction run on
-        // one substrate, and neither one mints a run of the analysis.
+        // 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,
-        runDerivation: (input) => triggerDeriveTableExec(deriveTableExec, input),
-        runAuthorizer: conversation.runAuthorizer,
+        sandboxClient: wf.dataProfile.sandboxClient,
         makeResolver: makeReportResolver,
-        ...(eyes ? { eyes } : {}),
-        ...(deps.resolveReportPageAsset ? { resolvePageAsset: deps.resolveReportPageAsset } : {}),
-        ...(deps.makeSessionPagePublisher ? { makeSessionPages: deps.makeSessionPagePublisher } : {}),
-        ...(deps.resolveReportPageUrl ? { resolvePageUrl: deps.resolveReportPageUrl } : {}),
-        ...(deps.provenance ? { provenance: deps.provenance } : {}),
-        ...(conversation.logger ? { logger: conversation.logger } : {}),
+        eyes,
+        resolvePageAsset: deps.resolveReportPageAsset,
+        makeSessionPages: deps.makeSessionPagePublisher,
+        resolvePageUrl: deps.resolveReportPageUrl,
+        provenance: deps.provenance,
+        logger: conversation.logger,
         toolOutputStore,
     });
     // The single registration point for every typed agent. A future thread type's
@@ -200,15 +219,43 @@ export function assembleCoreRuntime(deps) {
         conversation: conversationAgent,
         report: reportAgent,
     };
+    const agentResolver = createThreadAgentResolver(agents);
+    const askGateway = createAskGateway({ pool: conversation.pool });
+    const chatTurns = registerChatTurns({
+        pool: conversation.pool,
+        logger: conversation.logger,
+        provenance: deps.provenance,
+        agents: agentResolver,
+        provider: conversation.provider,
+        usageRecorder,
+        askGateway,
+        credentialFor: deps.credentialFor,
+        pauseRetryDelaysMs,
+    });
     return {
-        agents: createThreadAgentResolver(agents),
-        reportSession: { ensureSessionState: reportSession.ensureSessionState },
+        agents: agentResolver,
+        askGateway,
+        chatTurns,
+        work: createWork({
+            pool: conversation.pool,
+            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),
+        }),
+        reportSession: { ensureSessionState: reportSession.ensureSessionState.bind(reportSession) },
         workflows: {
             executeAnalysis,
             sandboxStep,
             dataProfile,
-            extractValues,
-            deriveTableExec,
         },
         citationResolver,
         approvePlan: (input) => approvePlan({
@@ -216,10 +263,10 @@ export function assembleCoreRuntime(deps) {
             executeAnalysisWorkflow: executeAnalysis,
             runAuthorizer: conversation.runAuthorizer,
             runLauncher: conversation.runLauncher,
-            ...(resourcePolicy ? { resourcePolicy } : {}),
-            ...(conversation.extendAnalysisFarm ? { extendAnalysisFarm: conversation.extendAnalysisFarm } : {}),
-            ...(conversation.logger ? { logger: conversation.logger } : {}),
-            ...(deps.provenance ? { provenance: deps.provenance } : {}),
+            resourcePolicy,
+            extendAnalysisFarm: conversation.extendAnalysisFarm,
+            logger: conversation.logger,
+            provenance: deps.provenance,
         }, input),
     };
 }

package/dist/runtime/boot.d.ts

@@ -2,7 +2,7 @@
  * `bootHarness` — the harness-owned boot sequence.
  *
  * `assembleCoreRuntime` stays sync and pure (it is the register-before-launch
- * cohort SOT, driven by tests on `passthroughStep`). `bootHarness` wraps it with
+ * cohort SOT, driven by tests outside a workflow). `bootHarness` wraps it with
  * the ordered, effectful boot steps every host must run in the same order, and
  * returns a `shutdown` handle the embedder wires to its process signals. The
  * ordering is load-bearing and runs cheapest-failure-first:
@@ -39,15 +39,16 @@
  * once shutdown starts, exiting takes precedence (see `runShutdownSequence`).
  */
 import type { Pool } from "pg";
+import type { Querier } from "../state/db.js";
 import type { Logger } from "../lib/logger.js";
 import { type CoreRuntime, type CoreRuntimeDeps } from "./assemble.js";
 import { type ConnectionBudgetConfig } from "./connection-budget.js";
 import { type DbosConfig } from "./dbos.js";
-export interface BootHarnessDeps {
+export type BootHarnessDeps = {
     /** Everything `assembleCoreRuntime` needs (workflow + conversation deps, resource policy). */
     readonly core: CoreRuntimeDeps;
-    /** App `pg.Pool` — used for state init, the connection-budget guard, and closed on shutdown. */
-    readonly pool: Pool;
+    /** The ledger pool — used for state init, the connection-budget guard, and closed on shutdown. */
+    readonly pool: Querier & Pick<Pool, "connect" | "end" | "options">;
     /** Skills root; validated against the harness-owned agent catalog before launch. */
     readonly skillsDir: string;
     /** DBOS launch config (carries the stable `executorId`). */
@@ -72,10 +73,10 @@ export interface BootHarnessDeps {
     readonly flushLogger?: () => Promise<void>;
     /** Process exit at shutdown. Default no-op — the embedder owns process lifecycle. */
     readonly exit?: (code: number) => void;
-}
-export interface BootedHarness {
+};
+export type BootedHarness = {
     readonly runtime: CoreRuntime;
     /** Runs the graceful-shutdown sequence in durability order. Wire to SIGTERM/SIGINT. */
     readonly shutdown: (signal: string) => Promise<void>;
-}
+};
 export declare function bootHarness(deps: BootHarnessDeps): Promise<BootedHarness>;