@inflexa-ai/harness 0.48.0 → 0.48.2

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

@@ -20,7 +20,6 @@
  * no terminal at all.
  */
 import type { Logger } from "../lib/logger.js";
-import type { ToolDetailResolver } from "../tools/detail-resolver.js";
 /**
  * Writes one part to the run-event stream. Injected rather than imported so this
  * module stays free of the durability engine and so a test can record what a
@@ -64,15 +63,12 @@ export type ProfileActivityEmitter = {
      * Reported per tool call the profiler agent makes, phrased by the shared
      * translator.
      *
-     * `resolveDetail` is built over the profiler agent's own tool list, so the
-     * phrase comes from the called tool's `describeCall` hook. It is passed per
-     * call rather than held by the emitter because the emitter exists before the
-     * agent does — `sandboxInit` is reported before the sandbox the agent's tools
-     * are bound to. The call site supplies a RESOLVER, never a phrase: the
+     * `detail` is the detail of the loop event, which the `describeCall` hook of
+     * the called tool made. The call site supplies a detail, never a phrase: the
      * phrases are this capability's observable contract, and a call site that
      * composed its own is a call site that can drift from it.
      */
-    forTool(toolUseId: string, name: string, input: unknown, resolveDetail?: ToolDetailResolver): Promise<void>;
+    forTool(toolUseId: string, name: string, detail?: string): Promise<void>;
     /** Reported for the vector-store pass that indexes per-file descriptions. */
     indexing(): Promise<void>;
     /** The success terminal. Emitted only after the terminal ledger write has landed. */

package/dist/tasks/data-profile-activity.js

@@ -58,7 +58,7 @@ export function createProfileActivityEmitter(write, frame, logger, now) {
         sandboxInit: () => emit("sandbox-init", "Starting sandbox"),
         scanning: () => emit("executing", "Scanning input files"),
         agentStarting: () => emit("executing", "Running data-profiler"),
-        forTool: (toolUseId, name, input, resolveDetail) => emit("executing", activityForTool(name, input, resolveDetail), toolUseId),
+        forTool: (toolUseId, name, detail) => emit("executing", activityForTool(name, detail), toolUseId),
         indexing: () => emit("indexing", "Indexing input descriptions for search"),
         complete: () => emit("complete", "Profile complete"),
         failed: (reason) => emit("failed", reason),

package/dist/tasks/data-profile.js

@@ -27,13 +27,12 @@ import { forStep, forSubAgent } from "../auth/types.js";
 import { presentFirst } from "../lib/present.js";
 import { collapseWhitespace } from "../lib/text.js";
 import { createDataProfilerAgent } from "../agents/sandbox/data-profiler.js";
-import { runWithSalvage, withRunScript } from "../loop/run-loop.js";
+import { runWithSalvage } from "../loop/run-loop.js";
 import { recordedInputOf } from "../loop/tool-adapter.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { deliverNotice, passGate } from "../lib/hooks.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { defineTool } from "../tools/define-tool.js";
-import { createDetailResolver } from "../tools/detail-resolver.js";
 import { renderResources, renderWorkspace } from "../prompts/briefing.js";
 import { workPause } from "../workflows/pause.js";
 import { clearPausesOfWork } from "../state/paused-work.js";
@@ -109,6 +108,7 @@ export function createSubmitProfileTool(detected, menu) {
             "A submission whose operations do not resolve, or that leaves kept files unclaimed, comes back with " +
             "the errors; the repair is a FULL resubmit of the whole operation list. The last accepted submission is the profile.",
         inputSchema: ProfileSubmissionSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => {
             const resolution = resolveProfileSubmission(input, detected, menu, { finalRound: false });
@@ -545,9 +545,6 @@ export async function runDataProfileBody(input, deps) {
             const submitProfileTool = createSubmitProfileTool(detected, briefingMenu);
             const baseAgent = createDataProfilerAgent(sandboxAgentDeps);
             const agentDef = { ...baseAgent, tools: [...baseAgent.tools, submitProfileTool] };
-            // The profiler's own roster, `submit_profile` included, so every call it
-            // makes is phrased by the tool that was called.
-            const resolveDetail = createDetailResolver([...withRunScript(agentDef).tools, ...(agentDef.scriptTools ?? [])], logger);
             const signal = new AbortController().signal;
             // Covers the gap between a ready sandbox and the agent's first tool call, which would
             // otherwise still read as `Starting sandbox` long after the container was up. The run
@@ -563,7 +560,7 @@ export async function runDataProfileBody(input, deps) {
                 // happening now. The events of a tool call arrive from inside its step.
                 emit: async (event) => {
                     if (event.type === "tool-started")
-                        await activity.forTool(event.toolUseId, event.name, event.input, resolveDetail);
+                        await activity.forTool(event.toolUseId, event.name, event.detail);
                 },
                 invocationId: workflowId,
                 usageRecorder: deps.usageRecorder,

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

@@ -125,6 +125,7 @@ function routeTool() {
         id: SUBMIT_ROUTE_TOOL_ID,
         description: "Submit the single specialist and the packages of the step. This is the only valid response.",
         inputSchema: routeSchema,
+        view: "none",
         describeCall: "none",
         execute: () => Promise.resolve(ok({ recorded: true })),
     });

package/dist/tools/bio/alphafold-prediction.js

@@ -29,6 +29,7 @@ export const alphafoldPredictionTool = defineTool({
     inputSchema: z.object({
         uniprotAccession: z.string().min(1).describe("A UniProt accession, for example 'P38398' (BRCA1) or 'P69905' (hemoglobin subunit alpha)."),
     }),
+    view: "none",
     describeCall: ({ uniprotAccession }) => uniprotAccession,
     execute: async ({ uniprotAccession }) => {
         // The client trims before it builds the URL, thus a miss echoes the same

package/dist/tools/bio/chembl.js

@@ -127,6 +127,7 @@ export const chemblTool = defineTool({
         "compounds here first. If ChEMBL misses the compound, resolve it via pubchem action='compound' and bridge back with pubchem action='crossrefs'.\n" +
         "An empty array is valid no-data, not an error — do not retry the same call.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ action, query, searchType, chemblId, idType, activityType, limit }) => {
         switch (action) {

package/dist/tools/bio/comptox.js

@@ -112,6 +112,7 @@ export function createComptoxTool(deps) {
             "This is environmental/industrial-chemical data: for drug-like compounds prefer PubChem or ChEMBL — dataset 'chemical' returns " +
             "`detail.pubchemCid` to bridge back.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const headers = getEpaCcteHeaders(deps.apiKey);

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

@@ -118,6 +118,7 @@ export function createDrugGeneInteractionsTool(deps) {
             "not be reached (a missing DRUGBANK_API_KEY lands here — state that the key is missing, and proceed with DGIdb). A `found: false` entry means the identifier " +
             "is not in DGIdb at all, usually a non-HUGO symbol or a brand name. Neither is worth retrying unchanged.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const inputs = typeof input.query === "string" ? [input.query] : input.query;

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

@@ -170,6 +170,7 @@ export function createGeneDiseaseEvidenceTool(deps) {
             "could not be reached (a missing DISGENET_API_KEY lands here — state that the key is missing, and proceed with the others); 'not_applicable' means that " +
             "corpus has no lookup for this queryType. Only 'no_data' is evidence of absence, and none is worth retrying unchanged.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const applicable = applicableSources(input.queryType);

package/dist/tools/bio/gene-preclinical-profile.js

@@ -138,6 +138,7 @@ export const genePreclinicalProfileTool = defineTool({
         "with no phenotype terms means the gene has not been IMPC-phenotyped, which is common; an empty hpoTerms list means Monarch curates no human " +
         "phenotype for the gene, and a null geneCurie means the symbol anchored on no HGNC id.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ geneSymbol, include, species, minRank, tissueLimit, phenotypeLimit }) => {
         const halves = include ?? ["expression", "knockout"];

package/dist/tools/bio/lookup-annotation.js

@@ -156,6 +156,7 @@ export const lookupAnnotationTool = defineTool({
         "An empty terms / annotations / pathways array is valid no-data — report it and continue, do not retry the same input. An empty pathways array " +
         "for a pathwayId means neither database holds that identifier.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ vocabulary, query, pathwayId, goId, geneProductId, taxonId, organism, includeGenes, limit, }) => {
         const cap = limit ?? DEFAULT_LIMIT;

package/dist/tools/bio/opentargets.js

@@ -89,6 +89,7 @@ export const openTargetsTool = defineTool({
         "NO-DATA IS FINAL — do not retry the same id. Empty associations mean no evidence, or an id the platform does not hold. An empty candidates " +
         "list means the name matched no disease: rephrase it, do not invent an id.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async (input) => {
         const limit = input.limit ?? DEFAULT_LIMIT;

package/dist/tools/bio/pubchem.js

@@ -83,6 +83,7 @@ export const pubchemTool = defineTool({
         "then chembl action='mechanism' / 'bioactivity' there for curated activity data. " +
         "An empty results / crossRefs / assays array is valid no-data (no match; the CID is in no external registry; the compound was never screened) — do not retry.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async (input) => {
         switch (input.action) {

package/dist/tools/bio/pubmed.js

@@ -163,6 +163,7 @@ export function createPubMedTool(deps) {
             "Report it and continue, do not retry it.",
         inputSchema,
         outputSchema,
+        view: "none",
         // One tool, three jobs. The action alone would still render three
         // different searches identically, so each action names its own subject:
         // the query, how many articles, or which article.

package/dist/tools/bio/search-clinical-trials.js

@@ -76,6 +76,7 @@ export const searchClinicalTrialsTool = defineTool({
         message: "nctId is required when action is 'details' — one NCT ID, e.g. 'NCT00000102'. Find one with action 'search'.",
         path: ["nctId"],
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ action, query, nctId, phase, status, limit, includeSummaries }) => {
         if (action === "details") {

package/dist/tools/bio/search-faers.js

@@ -70,6 +70,7 @@ export const searchFaersTool = defineTool({
         message: `limit is capped at ${LABEL_MAX_LIMIT} for action 'label' — each label version carries whole prose sections`,
         path: ["limit"],
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ action, drugName, limit, serious }) => {
         switch (action) {

package/dist/tools/bio/search-gene.js

@@ -66,6 +66,7 @@ export const searchGeneTool = defineTool({
             .describe("Gene identifiers to look up, mixed freely (e.g. ['BRCA1', 'ENSG00000141510', 'P38398', 'HGNC:1100', 'CHEMBL5619'])"),
         species: z.string().default("homo_sapiens").describe("Species name (e.g. 'homo_sapiens', 'mus_musculus')"),
     }),
+    view: "none",
     // The identifiers are the call. A large batch is summarized here rather than
     // left to the emit-site cap: that cap cuts at a character, so a 200-symbol
     // join arrives ending in `TP5` — a fragment that reads as a real symbol and

package/dist/tools/bio/search-geo-datasets.js

@@ -113,6 +113,7 @@ export const searchGeoDatasetsTool = defineTool({
             .default(10)
             .describe("Max datasets to return (default 10, max 50). totalFound reports the true match count regardless."),
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ query, organism, datasetType, limit }) => {
         let searchQuery = query;

package/dist/tools/bio/search-interactions.js

@@ -43,6 +43,7 @@ export const searchInteractionsTool = defineTool({
             .describe(`Max records returned — partners PER INPUT PROTEIN, network edges, or enriched terms depending on action (default ${DEFAULT_LIMIT}, max 500). ` +
             "Rows are ordered best-first (score descending for interactions, FDR ascending for enrichment), so the default keeps the strongest."),
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ identifiers, species, action, minScore, limit }) => {
         if (action === "enrichment") {

package/dist/tools/bio/search-patents.js

@@ -88,6 +88,7 @@ export function createSearchPatentsTool(deps) {
             "Requires AMASS_API_KEY — a missing key fails terminally: do NOT retry, tell the user the key needs configuring and proceed without " +
             "Amass patent data. Every call spends the user's Amass credits.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const headers = getAmassHeaders(deps.apiKey);

package/dist/tools/bio/search-protein.js

@@ -49,6 +49,7 @@ export const searchProteinTool = defineTool({
             .describe(`Max proteins returned (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}). An exact symbol under reviewedOnly resolves to one entry, so raise ` +
             "this only for a reviewedOnly=false survey, where a gene carries many TrEMBL rows."),
     }),
+    view: "none",
     describeCall: ({ query }) => query,
     execute: async ({ query, organismId, reviewedOnly, limit }) => {
         const result = await searchProteins(query, {

package/dist/tools/bio/search-regulatory-approvals.js

@@ -108,6 +108,7 @@ export function createSearchRegulatoryApprovalsTool(deps) {
             "Requires AMASS_API_KEY — a missing key fails terminally: do NOT retry; state that the key is not configured, and proceed without " +
             "Amass regulatory data. Every call spends the user's Amass credits.",
         inputSchema,
+        view: "none",
         describeCall: "none",
         execute: async (input) => {
             const headers = getAmassHeaders(deps.apiKey);

package/dist/tools/bio/target-safety.js

@@ -107,6 +107,7 @@ export const targetSafetyTool = defineTool({
         "means no CURATED liability, not that none exists. Both are valid no-data — do not retry. Read `perSource` and each row's `opentargetsNote`: a " +
         "ChEMBL or UniProt identifier absent from the panel cannot be resolved to an Ensembl id, so its Open Targets half is skipped rather than empty.",
     inputSchema,
+    view: "none",
     describeCall: "none",
     execute: async ({ identifiers, identifierType, sources, filterOrgan, minSeverity, liabilityLimit }) => {
         const selected = sources ?? [...SOURCES];

package/dist/tools/capability-data.js

@@ -52,6 +52,11 @@ export function createInspectCapabilityDataTool(deps = {}) {
             "It takes no arguments and the whole set is small, so one call is the complete answer. " +
             "An unreadable store answers UNKNOWN rather than absent, so a store that cannot be read never reads as a store that holds nothing.",
         inputSchema: CapabilityDataInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: () => "declared capability data",
         execute: async () => {
             const declared = declaredDataRequirements();

package/dist/tools/define-tool.d.ts

@@ -25,6 +25,7 @@ import type { AgentSession } from "../auth/types.js";
 import type { AgentRunUsage } from "../loop/metrics.js";
 import type { EmitFn } from "../loop/types.js";
 import type { AskRequest } from "./approval/contract.js";
+import type { ToolCallView } from "./tool-view.js";
 export type { EmitFn } from "../loop/types.js";
 /**
  * The error channel of a tool's `Result`. `error` is the message surfaced to
@@ -158,6 +159,8 @@ export type Tool<Input = unknown, Output = unknown> = {
     describeCall?(input: Input): string | undefined;
     /** See {@link ToolDefinition.describeResult}. Absent when the tool declares none. */
     describeResult?(input: Input, result: Output): string | undefined;
+    /** See {@link ToolDefinition.view}. Absent when the tool shows no value. */
+    view?: ToolCallView<Input, Output>;
     /**
      * See {@link ToolDefinition.foldCallRecord}. The record arrives untyped: the
      * loop passes back only what the `execute` of the same tool attached.
@@ -243,6 +246,21 @@ export type ToolDefinition<Schema extends z.ZodType<z.output<Schema>>, Output, O
      * The hook never reaches the model.
      */
     readonly describeResult?: (input: z.infer<Schema>, result: Output) => string | undefined;
+    /**
+     * What a call of this tool shows to a host: its input, its result, and its error as values with a kind. A tool
+     * shows only what it declares, thus the default of a tool is to show nothing.
+     *
+     * The decision is REQUIRED. Give a `ToolCallView`, or give the literal `"none"`. `"none"` declares that no call of
+     * the tool shows a value. `defineTool` consumes the sentinel at construction, and the sentinel never reaches a
+     * packaged tool.
+     *
+     * A member is synchronous and pure, like a `describeCall` hook, and it never reaches the model. A member gives a
+     * string for a `text` value, any other plain value for a `json` value, or the result of `viewText`, `viewJson`,
+     * `viewCode`, or `viewFields` for a value of a kind that the author chooses. The emit site then removes the control
+     * characters and the listed secret forms, and it cuts a long text. The view is the control for a secret in a form
+     * that no rule matches: a tool that holds such data declares a view that leaves it out.
+     */
+    view: ToolCallView<z.infer<Schema>, Output> | "none";
     /**
      * Fold the call record of one settled call into process-local state. The
      * record is the one that `execute` attached with `withToolCallRecord`.

package/dist/tools/define-tool.js

@@ -135,6 +135,8 @@ export function defineTool(def) {
     // property check on either side.
     if (def.describeResult !== undefined)
         packaged.describeResult = def.describeResult;
+    if (def.view !== "none")
+        packaged.view = def.view;
     if (def.ownStep === true)
         packaged = { ...packaged, ownStep: true };
     if (def.startsWorkflow === true)

package/dist/tools/display/show-user.js

@@ -71,6 +71,7 @@ export const showUserTool = defineTool({
         "One card per call, rendered in call order; an identical repeat call resolves to the same card, so compose the " +
         "finished content before calling rather than re-rendering a draft.",
     inputSchema: ShowUserInputSchema,
+    view: "none",
     describeCall: ({ kind, title }) => (title === undefined ? kind : `${kind}: ${title}`),
     execute: async (input, ctx) => {
         // `dataPath` is a reference the host resolves at render time; validate its

package/dist/tools/execute-analysis.js

@@ -625,6 +625,10 @@ export function createExecuteAnalysisTool(deps) {
             "A plan that already has an active run returns that run, so a second run of one plan does not start. " +
             "The launch fails with an error, and no run starts, when the plan is not found or fails validation, when a package of the plan cannot link, or when the run is not authorized.",
         inputSchema,
+        view: {
+            input: (input) => input,
+            error: true,
+        },
         // The mode is what a user most needs to see here — an approved plan
         // running is a different event from an ad hoc request being routed.
         describeCall: (input) => (input.mode === "plan" ? `plan ${input.planId ?? ""}` : `ad hoc: ${input.request ?? ""}`),

package/dist/tools/knowledge/check.d.ts

@@ -24,6 +24,7 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
         coexpression: "coexpression";
         deconvolution: "deconvolution";
         differential_expression: "differential_expression";
+        dose_response: "dose_response";
         enrichment: "enrichment";
         full_plan: "full_plan";
         qc: "qc";
@@ -31,9 +32,15 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
         survival: "survival";
         tf_activity: "tf_activity";
     }>;
-    modality: z.ZodLiteral<"bulk_rna_seq">;
+    modality: z.ZodEnum<{
+        bulk_rna_seq: "bulk_rna_seq";
+        microarray: "microarray";
+        tempo_seq: "tempo_seq";
+    }>;
     data_state: z.ZodEnum<{
         counts: "counts";
+        de_results: "de_results";
+        effect_sizes_only: "effect_sizes_only";
         fastq: "fastq";
         log_normalized: "log_normalized";
         tpm_or_fpkm: "tpm_or_fpkm";
@@ -53,9 +60,12 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
         unknown: "unknown";
     }>>;
     organism: z.ZodEnum<{
+        dog: "dog";
         human: "human";
+        monkey: "monkey";
         mouse: "mouse";
         other: "other";
+        rat: "rat";
     }>;
     n_groups: z.ZodNumber;
     n_per_group_min: z.ZodNumber;
@@ -69,6 +79,7 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
         litter: "litter";
         other: "other";
         pair: "pair";
+        plate: "plate";
         site: "site";
     }>>>;
     block_structure: z.ZodOptional<z.ZodEnum<{
@@ -119,10 +130,12 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
     classifier: z.ZodOptional<z.ZodBoolean>;
     extra_analyses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         annotation: "annotation";
+        classifier_call: "classifier_call";
         clustering: "clustering";
         coexpression: "coexpression";
         deconvolution: "deconvolution";
         pathway_activity: "pathway_activity";
+        reference_module_score: "reference_module_score";
         signature_scoring: "signature_scoring";
         survival: "survival";
         tf_activity: "tf_activity";
@@ -145,26 +158,59 @@ declare const KnowledgeCheckInputSchema: z.ZodObject<{
         outlier_sample: "outlier_sample";
         sample_identity_doubt: "sample_identity_doubt";
     }>>>;
+    tissue: z.ZodOptional<z.ZodEnum<{
+        adipose: "adipose";
+        blood: "blood";
+        brain: "brain";
+        heart: "heart";
+        kidney: "kidney";
+        liver: "liver";
+        muscle: "muscle";
+        other: "other";
+    }>>;
+    exposure_axis: z.ZodOptional<z.ZodEnum<{
+        administered_dose: "administered_dose";
+        in_vitro_concentration: "in_vitro_concentration";
+        systemic_exposure: "systemic_exposure";
+    }>>;
+    n_dose_levels: z.ZodOptional<z.ZodNumber>;
+    n_compounds: z.ZodOptional<z.ZodNumber>;
+    control_placement: z.ZodOptional<z.ZodEnum<{
+        per_block: "per_block";
+        per_time: "per_time";
+        per_time_and_block: "per_time_and_block";
+        single_baseline: "single_baseline";
+    }>>;
+    grid_complete: z.ZodOptional<z.ZodBoolean>;
+    recovery_group: z.ZodOptional<z.ZodBoolean>;
     steps: z.ZodArray<z.ZodObject<{
         step_type: z.ZodEnum<{
             annotation: "annotation";
+            benchmark_dose_sets: "benchmark_dose_sets";
+            classifier_call: "classifier_call";
             clustering: "clustering";
             coexpression: "coexpression";
             cohort_assembly: "cohort_assembly";
+            compendium_connectivity: "compendium_connectivity";
             deconvolution: "deconvolution";
             differential_expression: "differential_expression";
+            dose_response_fit: "dose_response_fit";
             enrichment: "enrichment";
+            exposure_margin: "exposure_margin";
             filter_low_counts: "filter_low_counts";
             model_design: "model_design";
             multiple_testing: "multiple_testing";
             normalize: "normalize";
             pathway_activity: "pathway_activity";
+            point_of_departure: "point_of_departure";
             qc_sample_structure: "qc_sample_structure";
+            reference_module_score: "reference_module_score";
             report: "report";
             shrink_lfc: "shrink_lfc";
             signature_scoring: "signature_scoring";
             survival: "survival";
             tf_activity: "tf_activity";
+            trajectory_classification: "trajectory_classification";
             transcript_level: "transcript_level";
             variance_partition: "variance_partition";
         }>;

package/dist/tools/knowledge/check.js

@@ -23,6 +23,14 @@ const DraftedStepSchema = z.object({
         "differential_expression",
         "shrink_lfc",
         "multiple_testing",
+        "dose_response_fit",
+        "benchmark_dose_sets",
+        "point_of_departure",
+        "exposure_margin",
+        "trajectory_classification",
+        "reference_module_score",
+        "classifier_call",
+        "compendium_connectivity",
         "enrichment",
         "variance_partition",
         "tf_activity",
@@ -67,7 +75,7 @@ export function createKnowledgeCheckTool(deps) {
     let calls = 0;
     return defineTool({
         id: "knowledge_check",
-        description: "Check the method steps you drafted for a bulk RNA-seq analysis against the rules of the Inflexa knowledge service, once, after the draft and before `submit_plan`. " +
+        description: "Check the method steps you drafted for an expression analysis against the rules of the Inflexa knowledge service, once, after the draft and before `submit_plan`. " +
             "Send the same situation you sent to `knowledge_recommend` and the drafted steps: the step type, the method as the step names it, its package, and its key parameters. " +
             "The answer lists `violations` (a forbidden method, or an inferential test on a design that a flag limits) and `warnings` (a method outside the set the rules name, a parameter that differs from a sourced default, or a required parameter that the step does not state), each with the rule id and the permitted alternatives. " +
             "Revise a violated step once, then submit. A warning is advice: keep the step when the data gives a reason, and state the reason in the step. `ok: true` means no finding on the assessed steps. " +
@@ -75,6 +83,7 @@ export function createKnowledgeCheckTool(deps) {
             "`match: unavailable` means the service did not answer, and `match: snapshot_mismatch` means the service moved to another release than the one your recommend answer came from; in both cases submit the draft as it is. " +
             `The host accepts ${CHECK_CALL_LIMIT} checks per plan; after that the tool refuses and you submit with the findings you have.`,
         inputSchema: KnowledgeCheckInputSchema,
+        view: "none",
         describeCall: ({ steps }) => `${steps.length} drafted step(s)`,
         describeResult: (_input, result) => ("ok" in result ? describeFindings(result) : result.match),
         execute: async (input) => {

package/dist/tools/knowledge/client.d.ts

@@ -20,7 +20,7 @@
 import { z } from "zod";
 import type { SituationFieldsSchema } from "./situation.js";
 /** The role of the blocking factor. A role and never a column name, because the situation leaves the machine. */
-export type BlockingRole = "individual" | "cell_line" | "litter" | "site" | "pair" | "other";
+export type BlockingRole = "individual" | "cell_line" | "litter" | "site" | "pair" | "plate" | "other";
 /** The role of a covariate of the design. A role and never a column name. */
 export type CovariateRole = "sex" | "age" | "clinical" | "technical" | "other";
 /** The role of the numeric variable of interest when the question is a trend, not a comparison of groups. */

package/dist/tools/knowledge/recommend.js

@@ -49,10 +49,10 @@ export function toPlannerAnswer(joined) {
 export function createKnowledgeRecommendTool(deps) {
     return defineTool({
         id: "knowledge_recommend",
-        description: "Get the cited, versioned procedure for a bulk RNA-seq analysis situation from the Inflexa knowledge service, folded into plan steps: " +
-            "which method for each step (QC, filter, normalize, model, test, shrinkage, multiple testing, enrichment, report), " +
+        description: "Get the cited, versioned procedure for an expression analysis situation (bulk RNA-seq, a microarray, or a TempO-Seq panel) from the Inflexa knowledge service, folded into plan steps: " +
+            "which method for each step (for example QC, filter, normalize, model, test, shrinkage, multiple testing, enrichment, dose-response fit, point of departure, report), " +
             "its settings with their sources, a tested script template per step, the rules that select them, and the evidence. " +
-            "Call it BEFORE you draft a method step for bulk RNA-seq differential expression, enrichment, or QC. " +
+            "Call it BEFORE you draft a method step for a differential expression, an enrichment, a QC, a dose response, or any other question that `question` names. " +
             "Fill the situation from the Data Context (the design, the replicate counts, the batch structure, the data state, the quality concerns); never send a sample name or a file path. " +
             `Example input: ${SITUATION_EXAMPLE}. ` +
             "The answer holds one representation: `plan_skeleton`, the plan steps with the id, the name, the track, the agent, the packages, the dependencies, " +
@@ -80,6 +80,7 @@ export function createKnowledgeRecommendTool(deps) {
             "That is the environment answer; do not call the listing tools for a package or a collection the answer already reports. " +
             "Call it once per situation; a second call with the same situation gives the same answer.",
         inputSchema: SituationFieldsSchema,
+        view: "none",
         describeCall: ({ question, n_per_group_min, n_per_group_max, batch }) => `${question}: ${n_per_group_min}-${n_per_group_max} per group, batch ${batch}`,
         describeResult: (_input, result) => result.match === "applicable" ? `${result.plan_skeleton.length} steps, ${result.claims.length} claims` : result.match,
         execute: async (input, ctx) => {

package/dist/tools/knowledge/situation.d.ts

@@ -12,6 +12,7 @@ export declare const SituationFieldsSchema: z.ZodObject<{
         coexpression: "coexpression";
         deconvolution: "deconvolution";
         differential_expression: "differential_expression";
+        dose_response: "dose_response";
         enrichment: "enrichment";
         full_plan: "full_plan";
         qc: "qc";
@@ -19,9 +20,15 @@ export declare const SituationFieldsSchema: z.ZodObject<{
         survival: "survival";
         tf_activity: "tf_activity";
     }>;
-    modality: z.ZodLiteral<"bulk_rna_seq">;
+    modality: z.ZodEnum<{
+        bulk_rna_seq: "bulk_rna_seq";
+        microarray: "microarray";
+        tempo_seq: "tempo_seq";
+    }>;
     data_state: z.ZodEnum<{
         counts: "counts";
+        de_results: "de_results";
+        effect_sizes_only: "effect_sizes_only";
         fastq: "fastq";
         log_normalized: "log_normalized";
         tpm_or_fpkm: "tpm_or_fpkm";
@@ -41,9 +48,12 @@ export declare const SituationFieldsSchema: z.ZodObject<{
         unknown: "unknown";
     }>>;
     organism: z.ZodEnum<{
+        dog: "dog";
         human: "human";
+        monkey: "monkey";
         mouse: "mouse";
         other: "other";
+        rat: "rat";
     }>;
     n_groups: z.ZodNumber;
     n_per_group_min: z.ZodNumber;
@@ -57,6 +67,7 @@ export declare const SituationFieldsSchema: z.ZodObject<{
         litter: "litter";
         other: "other";
         pair: "pair";
+        plate: "plate";
         site: "site";
     }>>>;
     block_structure: z.ZodOptional<z.ZodEnum<{
@@ -107,10 +118,12 @@ export declare const SituationFieldsSchema: z.ZodObject<{
     classifier: z.ZodOptional<z.ZodBoolean>;
     extra_analyses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         annotation: "annotation";
+        classifier_call: "classifier_call";
         clustering: "clustering";
         coexpression: "coexpression";
         deconvolution: "deconvolution";
         pathway_activity: "pathway_activity";
+        reference_module_score: "reference_module_score";
         signature_scoring: "signature_scoring";
         survival: "survival";
         tf_activity: "tf_activity";
@@ -133,6 +146,31 @@ export declare const SituationFieldsSchema: z.ZodObject<{
         outlier_sample: "outlier_sample";
         sample_identity_doubt: "sample_identity_doubt";
     }>>>;
+    tissue: z.ZodOptional<z.ZodEnum<{
+        adipose: "adipose";
+        blood: "blood";
+        brain: "brain";
+        heart: "heart";
+        kidney: "kidney";
+        liver: "liver";
+        muscle: "muscle";
+        other: "other";
+    }>>;
+    exposure_axis: z.ZodOptional<z.ZodEnum<{
+        administered_dose: "administered_dose";
+        in_vitro_concentration: "in_vitro_concentration";
+        systemic_exposure: "systemic_exposure";
+    }>>;
+    n_dose_levels: z.ZodOptional<z.ZodNumber>;
+    n_compounds: z.ZodOptional<z.ZodNumber>;
+    control_placement: z.ZodOptional<z.ZodEnum<{
+        per_block: "per_block";
+        per_time: "per_time";
+        per_time_and_block: "per_time_and_block";
+        single_baseline: "single_baseline";
+    }>>;
+    grid_complete: z.ZodOptional<z.ZodBoolean>;
+    recovery_group: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SituationFields = z.infer<typeof SituationFieldsSchema>;
 /** The situation as the client sends it: the fields as given, with the caller preference held out of the situation fields. */