@inflexa-ai/harness 0.46.2 → 0.47.0

package/dist/tools/report-session/derive-table.js

@@ -1,419 +0,0 @@
-/**
- * The derivation tool of a report session.
- *
- * A run writes statistical tables, and not plot-ready ones. This tool reshapes the pinned evidence into one
- * table that a block can bind: a join, a pivot, or an aggregate. The agent writes the script, and the record
- * chains the derived table back to the evidence that made it.
- *
- * A session derivation is not an analysis run. It mints no run id, no mandate, and no artifact, and it writes
- * under the session directory alone. The rails are the rails of the value tier (`tasks/extract-values.ts`):
- * one ephemeral container inside the step of the call (`sandbox/step-sandbox.ts`), which goes away with the
- * work. The container stays until the record lands, thus a rerun of the step before the record adopts the
- * container and the exec record of the first attempt, and the script does not run again. A rerun after the
- * record finds the record of its call, and it gives that table back.
- *
- * The container mounts the analysis tree read-only, and one write mount covers the `derived/` directory of
- * the session alone. The script writes its table into that mount directly, thus a large table makes no
- * roundtrip and no write of the script can reach the workspace tree. The working directory of the exec is
- * that same mount, and the standard output carries the logs of the script alone.
- *
- * The host then reads the file that the container wrote. A path inside the mount is still untrusted bytes: a
- * script can leave a symbolic link in place of its output. Thus the host classifies the file against the
- * workspace root before it hashes one byte, and an escape refuses as typed data.
- *
- * Each declared input must sit in the served membership, and its hash comes from there. The declaration is
- * what the record pins, thus a derived cell traces to a pinned artifact and to the script that read it.
- *
- * The tool refuses an output name that the membership already holds. A record is immutable, and a second
- * derivation of one table takes a new name.
- *
- * A composition with no sandbox client cannot derive at all. The tool reports that condition one time, up
- * front, the same discipline as the eyes. A per-attempt failure would instead read as a transient fault, and
- * it would invite a repeat of a call that can never pass.
- */
-import { ok } from "neverthrow";
-import { join } from "node:path";
-import { z } from "zod";
-import { createNoopLogger } from "../../lib/console-logger.js";
-import { classifyWithinRoot, computeSha256, computeSha256File } from "../../lib/fs-helpers.js";
-import { defaultErrorFields } from "../../lib/logger.js";
-import { snapshotEntry } from "../../report-model/reference-resolver.js";
-import { isWorkflowCancellation } from "../../runtime/dbos.js";
-import { passSpawnSession, withStepSandbox } from "../../sandbox/step-sandbox.js";
-import { isSafeId, reportSessionDerivedDir, toSandboxPath } from "../../workspace/paths.js";
-import { defineTool } from "../define-tool.js";
-import { openReportThread } from "../report-authoring/authoring-tools.js";
-import { bindSessionEmit } from "../../provenance/seam.js";
-import { readHeaderColumns } from "./list-artifacts.js";
-/** The input of one derivation: the script, the declared pinned inputs, and the name of the output file. */
-const deriveTableInput = z.object({
-    script: z.string().min(1),
-    inputs: z.array(z.string()).min(1),
-    output: z.string().min(1),
-});
-/** The synthetic run id and step id of one derivation. Both are constants, and neither names a run row. */
-const DERIVE_RUN_LITERAL = "derive-table";
-const DERIVE_STEP_LITERAL = "derive";
-/** The provenance agent id. No agent loop runs in the container, thus this names the derivation pass. */
-const DERIVE_AGENT_ID = "table-deriver";
-/** The exec budget of one derivation. It matches the budget of the value tier. */
-const DERIVATION_DEADLINE_MS = 300_000;
-/**
- * The container size of one derivation. A join or a pivot loads each declared input into pandas at one
- * time, thus the container needs the headroom of the value tier.
- */
-const DERIVATION_RESOURCES = { cpu: 2, memoryGb: 8 };
-/** The cap of the script, in bytes. A reshaping script sits far under it, and the command line carries it. */
-const SCRIPT_CAP_BYTES = 64 * 1024;
-/** The cap of the declared inputs. One derivation reads the evidence of a few artifacts, and never a tree. */
-const INPUT_CAP = 20;
-/** The environment variable that carries the declared inputs into the container. */
-export const DERIVE_INPUT_ENV = "DERIVE_INPUTS";
-/** The environment variable that carries the container path of the output file into the container. */
-export const DERIVE_OUTPUT_ENV = "DERIVE_OUTPUT";
-/**
- * The shell of the exec: clear the output path, then run the script. The script rides as the first
- * positional argument, thus `python3 -c` gets it byte for byte.
- *
- * The clearance belongs to the exec, and not to the host. A failed derivation can leave a file at the name
- * that this one declares, and a script that writes nothing must not adopt those bytes as its table.
- * sandbox-server runs one exec id one time, thus a rerun that attaches to the exec of an earlier attempt
- * keeps the table of that exec. A clearance on the host would remove it.
- */
-const CLEAR_THEN_RUN = `rm -f -- "$${DERIVE_OUTPUT_ENV}" && exec python3 -c "$1"`;
-/** The cap of the failure detail that the tool copies out of the standard error of the script. */
-const STDERR_TAIL_CAP = 2_000;
-/** The line that the agent reads when the composition binds no sandbox rails. */
-const NO_SANDBOX_DETAIL = "the composition gives no sandbox, thus this session cannot derive a table";
-/**
- * Build the sandbox exec of one derivation. The command clears the output path, and then it runs the script
- * of the agent through `python3 -c`.
- *
- * The working directory is the write mount, thus the script writes its table beside where it stands. Each
- * declared input rides as its mounted path, thus the script opens the file wherever it works from. The
- * output path rides too, thus the script names no directory of its own.
- *
- * The function is pure, thus a test asserts the command shape without a sandbox.
- */
-export function buildDerivationExec(args) {
-    return {
-        command: ["sh", "-c", CLEAR_THEN_RUN, "derive_table", args.script],
-        cwd: args.workingDir,
-        env: {
-            [DERIVE_INPUT_ENV]: JSON.stringify(args.inputs.map((input) => ({ path: input.path, hash: input.hash }))),
-            [DERIVE_OUTPUT_ENV]: args.output,
-        },
-        timeoutSeconds: Math.floor(DERIVATION_DEADLINE_MS / 1000),
-    };
-}
-/**
- * Give the failure of an exec result, or `undefined` when the script ran to a clean exit.
- *
- * A synthetic failure, a timeout, and a non-zero exit each mean that no table came back. The detail of a
- * non-zero exit carries the tail of the standard error, thus the agent repairs the script from what the
- * container reported.
- *
- * The function is pure, thus a test asserts the mapping without a sandbox.
- */
-export function describeExecFailure(result) {
-    if (result.syntheticFailure !== undefined) {
-        return `the derivation sandbox failed: ${result.syntheticFailure.reason}`;
-    }
-    if (result.timedOut) {
-        return "the derivation reached the deadline";
-    }
-    if (result.exitCode !== 0) {
-        const tail = result.stderr.slice(-STDERR_TAIL_CAP).trim();
-        const exit = `the script exited with code ${String(result.exitCode)}`;
-        return tail.length === 0 ? exit : `${exit}: ${tail}`;
-    }
-    return undefined;
-}
-/**
- * Make the derivation tool over the session-state gateway, the derivation ledger, and the sandbox rails.
- *
- * The tool reads the thread id from the scope of the call, and it loads the membership through the gateway.
- * Thus one factory serves every thread, and the tool holds no per-session value.
- */
-export function createDeriveTableTool(deps) {
-    const logger = (deps.logger ?? createNoopLogger()).named("derive-table");
-    const observe = bindSessionEmit(deps.provenance, logger);
-    const observeDerived = (analysisId, threadId, result) => {
-        if (result.outcome !== "derived")
-            return;
-        observe({
-            type: "run-derivation",
-            analysisId,
-            threadId,
-            outputPath: result.path,
-            outputHash: result.hash,
-            scriptHash: result.scriptHash,
-            sources: result.sources,
-        });
-    };
-    const { sandboxClient } = deps;
-    return defineTool({
-        id: "derive_table",
-        description: "Derive one table from the pinned evidence with a Python script, and pin the result to this session. " +
-            "Reach for it when a real reshaping stands between the evidence and the block: a join of two tables, a pivot, or an aggregate. " +
-            "A per-row transform is not a derivation, because a chart block reads the column that it needs. " +
-            "Name each pinned path that the script reads in `inputs`: each one must sit in the pinned evidence, and the record pins its hash. " +
-            'Give the file name of the result in "output": one name, with no directory and no separator, for example "yield_by_group.csv". ' +
-            `The script reads the ${DERIVE_INPUT_ENV} environment variable for its inputs: a JSON list that gives the mounted path and the hash of each declared one. ` +
-            `It writes the whole table as CSV to the path in the ${DERIVE_OUTPUT_ENV} environment variable, which sits in the working directory of the script. ` +
-            "That directory is the one place that the script can write: the analysis mounts read-only, and the container has no network. " +
-            "The standard output carries the logs of the script alone, thus a table that it prints there reaches nobody. " +
-            "The derived table joins the pinned evidence of this session, thus a block binds its path the same way as a pinned artifact. " +
-            "A name that this session already derived is refused, thus a second derivation of one table takes a new name. " +
-            `Limits: the script holds at most ${String(SCRIPT_CAP_BYTES / 1024)} KiB, inputs holds at most ${String(INPUT_CAP)} paths, ` +
-            `and the run stops after ${String(DERIVATION_DEADLINE_MS / 1000)} seconds. ` +
-            "A failed script gives back exec-failed with the tail of its standard error. " +
-            "The outcome unavailable means that this host cannot run a derivation, and a repeat gives the same outcome.",
-        inputSchema: deriveTableInput,
-        describeCall: (input) => `derive ${input.output}`,
-        // The derived path is the one durable product of the call, thus the derived arm names it. Each other
-        // arm is a condition that refused, and the kind of the arm is what a watcher must read.
-        describeResult: (_input, result) => (result.outcome === "derived" ? result.path : result.outcome),
-        execute: async (input, ctx) => {
-            // The check runs before every read, thus one clear signal replaces a failure for each attempt.
-            // It also narrows the rail below, thus the exec needs no assertion.
-            if (sandboxClient === undefined) {
-                logger.warn("the composition gives no sandbox, thus no derivation can run");
-                return ok({ outcome: "unavailable", detail: NO_SANDBOX_DETAIL });
-            }
-            const opened = await openReportThread(deps.gateway, ctx.session.scope);
-            if (opened.isErr()) {
-                return ok({ outcome: "refused", refusal: opened.error });
-            }
-            const { threadId, analysisId, state, derivations } = opened.value;
-            const bytes = Buffer.byteLength(input.script, "utf8");
-            if (bytes > SCRIPT_CAP_BYTES) {
-                return ok({
-                    outcome: "script-too-large",
-                    bytes,
-                    cap: SCRIPT_CAP_BYTES,
-                    detail: `the script is ${String(bytes)} bytes, and the cap is ${String(SCRIPT_CAP_BYTES)} bytes`,
-                });
-            }
-            // A repeated path names one source, thus the list keeps the first occurrence and the record pins
-            // each source one time.
-            const declared = [...new Set(input.inputs)];
-            if (declared.length > INPUT_CAP) {
-                return ok({
-                    outcome: "too-many-inputs",
-                    count: declared.length,
-                    cap: INPUT_CAP,
-                    detail: `the call declares ${String(declared.length)} inputs, and the cap is ${String(INPUT_CAP)}`,
-                });
-            }
-            if (!isSafeId(input.output)) {
-                return ok({
-                    outcome: "unsafe-name",
-                    detail: "the output names one file, with no directory, no separator, and no traversal",
-                });
-            }
-            // Each declared input takes its hash from the served membership. A path that the membership does
-            // not hold has no pinned hash, thus the record could chain nothing to it.
-            const sources = [];
-            for (const path of declared) {
-                const entry = snapshotEntry(state.snapshot, path);
-                if (entry === undefined) {
-                    return ok({
-                        outcome: "absent-input",
-                        path,
-                        detail: `the pinned evidence of this session holds no artifact at ${path}`,
-                    });
-                }
-                sources.push({ path, hash: entry.hash });
-            }
-            // The write tail is the one writable mount of the container, and the output sits inside it. Both
-            // compose from the session-directory builder, thus the layout has one owner.
-            const writableTail = reportSessionDerivedDir(threadId);
-            const outputPath = `${writableTail}/${input.output}`;
-            let root;
-            try {
-                root = await deps.resolveWorkspaceRoot(analysisId);
-            }
-            catch (cause) {
-                logger.warn("the workspace root did not resolve", { threadId, analysisId, ...defaultErrorFields(cause) });
-                return ok({ outcome: "unavailable", detail: "the workspace root did not resolve, thus the derived table has no place to land" });
-            }
-            // A rerun of a call whose record landed gives that record back. The membership holds the output of
-            // the record by now, thus the name test below would refuse the call its own table.
-            const recorded = derivations.find((record) => record.toolCallId === ctx.invocationId);
-            if (recorded !== undefined) {
-                const replayed = {
-                    outcome: "derived",
-                    path: recorded.outputPath,
-                    hash: recorded.outputHash,
-                    scriptHash: recorded.scriptHash,
-                    sources: [...recorded.sources],
-                    columns: await readColumnsQuietly(outputPath, join(root, outputPath), logger),
-                };
-                // A crash between the record and the emit of the earlier run loses its event, thus the rerun
-                // emits again. A consumer can get the act two times, never zero times.
-                observeDerived(analysisId, threadId, replayed);
-                return ok(replayed);
-            }
-            // The served membership carries each derivation of the session, thus this one test refuses a
-            // repeated name and a collision with a pinned artifact alike.
-            if (snapshotEntry(state.snapshot, outputPath) !== undefined) {
-                return ok({
-                    outcome: "repeated-name",
-                    outputPath,
-                    detail: `the evidence of this session already holds ${outputPath}, thus this derivation takes a new name`,
-                });
-            }
-            const result = await derive({
-                sandboxClient,
-                session: passSpawnSession(ctx.session, {
-                    analysisId,
-                    runId: DERIVE_RUN_LITERAL,
-                    stepId: DERIVE_STEP_LITERAL,
-                    agentId: DERIVE_AGENT_ID,
-                }),
-                derivations: deps.derivations,
-                root,
-                threadId,
-                analysisId,
-                toolCallId: ctx.invocationId,
-                script: input.script,
-                sources,
-                writableTail,
-                outputPath,
-                outputName: input.output,
-                logger,
-            });
-            // The record of the derivation lands before this point, thus the event states a table that the
-            // session already holds as evidence. Each other arm derived nothing.
-            observeDerived(analysisId, threadId, result);
-            return ok(result);
-        },
-    });
-}
-/**
- * Run one derivation and record what the script wrote.
- *
- * The order is the order of the evidence. The script writes into the write mount, the host classifies the
- * file, the hash comes off the disk, and the record lands last. Thus the recorded hash is the hash of the
- * file that a verifier reads. The container goes away after the record.
- *
- * The classification is the guard of the read. A script can leave a symbolic link at the output name, and a
- * link that resolves outside the tree would otherwise carry a host file into the evidence of the session.
- */
-async function derive(args) {
-    const absolute = join(args.root, args.outputPath);
-    // The container sees the tree at its own mount point, thus each path that the script reads maps through
-    // the one host-to-container mapper and never through a formula here. The mapper refuses a stored path
-    // that escapes the root with a throw. It runs before the try, thus that refusal stays a throw and it never
-    // reads as a fault of the container.
-    const request = buildDerivationExec({
-        script: args.script,
-        workingDir: toSandboxPath(args.root, args.analysisId, join(args.root, args.writableTail)),
-        inputs: args.sources.map((source) => ({ path: toSandboxPath(args.root, args.analysisId, join(args.root, source.path)), hash: source.hash })),
-        output: toSandboxPath(args.root, args.analysisId, absolute),
-    });
-    let ran;
-    try {
-        ran = await withStepSandbox(args.sandboxClient, { session: args.session, spec: { resources: DERIVATION_RESOURCES, writableTail: args.writableTail } }, args.logger, async (exec) => {
-            const failure = describeExecFailure(await exec(request, DERIVATION_DEADLINE_MS));
-            if (failure !== undefined) {
-                return { outcome: "exec-failed", detail: failure };
-            }
-            return recordDerivedTable({ ...args, absolute });
-        });
-    }
-    catch (cause) {
-        if (isWorkflowCancellation(cause))
-            throw cause;
-        args.logger.error("the derivation exec did not complete", { threadId: args.threadId, ...defaultErrorFields(cause) });
-        return { outcome: "exec-failed", detail: "the derivation exec did not complete" };
-    }
-    if (ran.isErr()) {
-        return {
-            outcome: "suspended",
-            reason: ran.error.reason,
-            detail: `the host refused the sandbox (${ran.error.reason}), thus the derivation did not run`,
-        };
-    }
-    return ran.value;
-}
-/** Classify, hash, and record the table that a green script wrote. */
-async function recordDerivedTable(args) {
-    const verdict = await classifyWithinRoot(args.root, args.absolute).catch((cause) => {
-        args.logger.error("the derived table did not classify", { threadId: args.threadId, ...defaultErrorFields(cause) });
-        return "escaped";
-    });
-    if (verdict === "absent") {
-        // A clean exit with no file at the output path means that the script wrote nothing, or that it wrote
-        // under a different name inside the mount. Either way this derivation has no table.
-        return {
-            outcome: "no-output",
-            detail: `the script ran to a clean exit and it wrote no file at ${args.outputName}`,
-        };
-    }
-    if (verdict === "escaped") {
-        args.logger.error("the derived table resolves outside the workspace root", { threadId: args.threadId, path: args.outputPath });
-        return { outcome: "exec-failed", detail: `${args.outputName} resolves outside the workspace tree, thus it is not evidence of this session` };
-    }
-    let outputHash;
-    try {
-        outputHash = await computeSha256File(args.absolute);
-    }
-    catch (cause) {
-        args.logger.error("the derived table did not hash", { threadId: args.threadId, ...defaultErrorFields(cause) });
-        return { outcome: "exec-failed", detail: "the derived table did not hash" };
-    }
-    const record = {
-        outputPath: args.outputPath,
-        outputHash,
-        sources: [...args.sources],
-        scriptHash: computeSha256(Buffer.from(args.script, "utf8")),
-        script: args.script,
-        toolCallId: args.toolCallId,
-    };
-    const appended = await args.derivations.appendDerivation(args.threadId, record);
-    if (appended.isErr()) {
-        args.logger.error("the derivation record did not land", { threadId: args.threadId, ...args.logger.errorFields(appended.error.cause) });
-        return { outcome: "exec-failed", detail: "the derivation record did not land, thus the table is not evidence of this session" };
-    }
-    if (appended.value === "duplicate") {
-        // The membership test above already refused a repeated name. A duplicate here means that another
-        // turn landed the same name inside this call, thus the name rule of the store is the last word.
-        return {
-            outcome: "repeated-name",
-            outputPath: args.outputPath,
-            detail: `another turn recorded ${args.outputPath} first, thus this derivation takes a new name`,
-        };
-    }
-    if (appended.value === "absent") {
-        args.logger.error("the derivation record matched no session row", { threadId: args.threadId });
-        return { outcome: "exec-failed", detail: "no report session state row exists to hold the derivation" };
-    }
-    // The columns describe the derived table the same way as the listing describes a pinned one. A file that
-    // gives no header gives no columns, and absence is a normal condition here.
-    const columns = await readColumnsQuietly(args.outputPath, args.absolute, args.logger);
-    return {
-        outcome: "derived",
-        path: args.outputPath,
-        hash: outputHash,
-        scriptHash: record.scriptHash,
-        sources: [...args.sources],
-        columns,
-    };
-}
-/**
- * The header columns of the derived table, or `undefined` when the read gives none.
- *
- * The derivation already landed at this point, thus a read fault costs the columns alone. The read never
- * throws for an absent file, and this guard covers a genuine fault of the disk.
- */
-async function readColumnsQuietly(path, absolute, logger) {
-    try {
-        return await readHeaderColumns(path, absolute);
-    }
-    catch (cause) {
-        logger.warn("the derived table gave no columns", { path, ...defaultErrorFields(cause) });
-        return undefined;
-    }
-}

package/dist/tools/research/literature-reviewer.d.ts

@@ -1,42 +0,0 @@
-/**
- * literatureReviewer — a sub-agent packaged as a loop-driving tool.
- *
- * The conversation agent delegates batch literature/biology research by
- * calling this tool. `execute` derives a child `Session` (`forSubAgent`)
- * and runs `runLoop` over a focused literature-reviewer agent: a research
- * brief in, a structured evidence report out. The child's transcript is
- * ephemeral — it lives only for this call and is never persisted (see the harness-thread-store spec).
- *
- * This is the whole of sub-agent delegation in the harness. There is no
- * `agents: {}` config, no `messageFilter`, no `stripParentToolParts`: the
- * child cannot see the parent's tool history because it is simply handed
- * none — only the brief. Inside the body of a workflow the call starts a
- * child workflow (`loop/sub-agent.ts`), thus each call of the child is a step
- * of its own.
- */
-import type { SubAgentRegistrar } from "../../loop/sub-agent.js";
-import type { ToolOutputStore } from "../../loop/tool-output.js";
-import { type ChatProvider } from "../../providers/types.js";
-import { type Tool } from "../define-tool.js";
-import { type BioToolKeys } from "../bio/keys.js";
-import type { Logger } from "../../lib/logger.js";
-import type { UsageRecorder } from "../../billing/usage-recorder.js";
-import type { CitationResolver } from "../../citations/types.js";
-export type LiteratureReviewerDeps = {
-    /** Operational logging seam; omitted falls back to no-op. */
-    readonly logger?: Logger;
-    /** The LLM seam the child loop runs on. */
-    readonly provider: ChatProvider;
-    /** Model id — provenance / metric label; the provider owns the wire model. */
-    readonly model: string;
-    /** API keys for the bio/chem data sources the reviewer searches. */
-    readonly bioKeys: BioToolKeys;
-    /** LLM usage-accounting seam for the child loop; omitted falls back to the no-op recorder. */
-    readonly usageRecorder?: UsageRecorder;
-    /** The store of the child loop and of its read tool. */
-    readonly toolOutputStore?: ToolOutputStore;
-    /** Shared bibliographic verification service; all agent surfaces share its pacing/cache. */
-    readonly citationResolver: CitationResolver;
-};
-/** Build the `literature_reviewer` delegation tool bound to its provider. */
-export declare function createLiteratureReviewerTool(deps: LiteratureReviewerDeps, registerSubAgent: SubAgentRegistrar): Tool;

package/dist/tools/research/literature-reviewer.js

@@ -1,107 +0,0 @@
-/**
- * literatureReviewer — a sub-agent packaged as a loop-driving tool.
- *
- * The conversation agent delegates batch literature/biology research by
- * calling this tool. `execute` derives a child `Session` (`forSubAgent`)
- * and runs `runLoop` over a focused literature-reviewer agent: a research
- * brief in, a structured evidence report out. The child's transcript is
- * ephemeral — it lives only for this call and is never persisted (see the harness-thread-store spec).
- *
- * This is the whole of sub-agent delegation in the harness. There is no
- * `agents: {}` config, no `messageFilter`, no `stripParentToolParts`: the
- * child cannot see the parent's tool history because it is simply handed
- * none — only the brief. Inside the body of a workflow the call starts a
- * child workflow (`loop/sub-agent.ts`), thus each call of the child is a step
- * of its own.
- */
-import { err, ok } from "neverthrow";
-import { z } from "zod";
-import { finalText, runLoop } from "../../loop/run-loop.js";
-import { literatureReviewerPrompt } from "../../prompts/literature-reviewer.js";
-import { composeSystemPrompt } from "../../agents/system-prompt.js";
-import { forSubAgent } from "../../auth/types.js";
-import { defineTool } from "../define-tool.js";
-import { createReadToolOutputTool } from "../read-tool-output.js";
-import { createChemDbTools, createNcbiTools } from "../bio/keys.js";
-import { genePreclinicalProfileTool } from "../bio/gene-preclinical-profile.js";
-import { lookupAnnotationTool } from "../bio/lookup-annotation.js";
-import { searchGeneTool } from "../bio/search-gene.js";
-import { searchProteinTool } from "../bio/search-protein.js";
-import { searchInteractionsTool } from "../bio/search-interactions.js";
-import { createResolveCitationTool } from "./resolve-citation.js";
-/** Sub-agent identity — appended to `callPath`, set as `agentId`. */
-const AGENT_ID = "literature-reviewer";
-/** Multi-tool research budget — search → read → synthesize over many genes. */
-const REVIEWER_MAX_ITERATIONS = 30;
-/** Build the `literature_reviewer` delegation tool bound to its provider. */
-export function createLiteratureReviewerTool(deps, registerSubAgent) {
-    const ncbi = createNcbiTools(deps.bioKeys);
-    const chemDb = createChemDbTools(deps.bioKeys, { logger: deps.logger });
-    const reviewerTools = [
-        searchGeneTool,
-        searchProteinTool,
-        lookupAnnotationTool,
-        searchInteractionsTool,
-        ncbi.pubmed,
-        createResolveCitationTool(deps.citationResolver),
-        chemDb.drugGeneInteractions,
-        genePreclinicalProfileTool,
-        ...(deps.toolOutputStore ? [createReadToolOutputTool(deps.toolOutputStore)] : []),
-    ];
-    const agent = {
-        id: AGENT_ID,
-        systemPrompt: composeSystemPrompt(literatureReviewerPrompt),
-        model: deps.model,
-        tools: reviewerTools,
-        maxIterations: REVIEWER_MAX_ITERATIONS,
-    };
-    // A review ends with a report, or with the finish reason of a run that gave none.
-    const review = registerSubAgent(AGENT_ID, async ({ payload, ctx, loop }) => {
-        const { messages: transcript, finish } = await runLoop(agent, [{ role: "user", content: payload.brief }], forSubAgent(ctx.session, AGENT_ID), {
-            ...loop,
-            provider: deps.provider,
-            usageRecorder: deps.usageRecorder,
-            toolOutputStore: deps.toolOutputStore,
-        });
-        const report = finalText(transcript);
-        return report.trim() === "" ? { finishReason: finish.reason } : { report };
-    });
-    return defineTool({
-        id: "literature_reviewer",
-        description: "Delegate batch literature/biology research to a sub-agent: looking up " +
-            "multiple genes or pathways, validating findings against published " +
-            "knowledge, or building evidence profiles. The reviewer holds gene, " +
-            "protein, annotation, interaction, PubMed, citation-verification, " +
-            "drug-gene and preclinical-profile lookups. It cannot see this " +
-            "conversation, the workspace, or the analysis files, thus pass a " +
-            "self-contained brief. One call runs a multi-step research loop of up " +
-            "to 30 model turns. Returns {report}: a Markdown evidence report with " +
-            "an evidence summary per target, cross-target patterns, and key " +
-            "references with PMIDs. A run that ends with no report returns a " +
-            "retryable error that names the finish reason.",
-        inputSchema: z.object({
-            brief: z
-                .string()
-                .min(1)
-                .describe("A self-contained research brief: the genes, pathways, or " +
-                "biological features to investigate and the experimental " +
-                "context. The reviewer sees only this — include everything it needs."),
-        }),
-        describeCall: "none",
-        startsWorkflow: true,
-        execute: async ({ brief }, ctx) => {
-            const reviewed = await review({ brief }, ctx);
-            // A child run can end with no final text. Examples are a terminal
-            // reply with no text block, and a run that reached its step cap. An
-            // ok result with an empty report hides that failure, so the tool
-            // returns an error that names the finish reason.
-            if ("finishReason" in reviewed) {
-                return err({
-                    error: `The literature reviewer gave no report (finish reason: ${reviewed.finishReason}). Retry, or narrow the brief.`,
-                    retryable: true,
-                });
-            }
-            return ok({ report: reviewed.report });
-        },
-    });
-}

package/dist/workflows/metrics.d.ts

@@ -1,23 +0,0 @@
-/**
- * Workflow-side OTel metrics.
- *
- *   - cortex.workflow.parent.cancelled_children — counter, incremented once
- *     per child the fail-fast or pause cascade reaps. A baseline near 0
- *     means runs land cleanly; a spike means siblings keep colliding with
- *     a single failing step.
- *
- * Instruments are lazy so the workflow body binds to whichever
- * `MeterProvider` is globally registered at startup.
- */
-/**
- * Record one child cancellation. The parent calls this once per
- * `DBOS.cancelWorkflow(childWorkflowId)` in the cascade (fail-fast OR
- * suspension). `cause` is `fail_fast`, `external_cancel`, or the reason of
- * the host for a suspension, carried unread, so dashboards can split the
- * counter by the reason that the host gave.
- */
-export declare function recordCancelledChild(args: {
-    readonly cause: string;
-}): void;
-/** Test hook — drop memoised instruments to rebind a fresh MeterProvider. */
-export declare function __resetWorkflowMetricsForTest(): void;

package/dist/workflows/metrics.js

@@ -1,38 +0,0 @@
-/**
- * Workflow-side OTel metrics.
- *
- *   - cortex.workflow.parent.cancelled_children — counter, incremented once
- *     per child the fail-fast or pause cascade reaps. A baseline near 0
- *     means runs land cleanly; a spike means siblings keep colliding with
- *     a single failing step.
- *
- * Instruments are lazy so the workflow body binds to whichever
- * `MeterProvider` is globally registered at startup.
- */
-import { metrics } from "@opentelemetry/api";
-let instruments;
-function getInstruments() {
-    if (instruments === undefined) {
-        const meter = metrics.getMeter("cortex.workflow");
-        instruments = {
-            cancelledChildren: meter.createCounter("cortex.workflow.parent.cancelled_children", {
-                description: "Children cancelled by the parent's fail-fast or suspension cascade",
-            }),
-        };
-    }
-    return instruments;
-}
-/**
- * Record one child cancellation. The parent calls this once per
- * `DBOS.cancelWorkflow(childWorkflowId)` in the cascade (fail-fast OR
- * suspension). `cause` is `fail_fast`, `external_cancel`, or the reason of
- * the host for a suspension, carried unread, so dashboards can split the
- * counter by the reason that the host gave.
- */
-export function recordCancelledChild(args) {
-    getInstruments().cancelledChildren.add(1, { cause: args.cause });
-}
-/** Test hook — drop memoised instruments to rebind a fresh MeterProvider. */
-export function __resetWorkflowMetricsForTest() {
-    instruments = undefined;
-}