@inflexa-ai/harness 0.48.1 → 0.48.3

package/dist/tools/knowledge/situation.js

@@ -18,16 +18,28 @@ export const SituationFieldsSchema = z.object({
         "clustering",
         "survival",
         "signature_scoring",
+        "dose_response",
     ])
         .describe("What the plan needs a procedure for. `full_plan` returns QC, filtering, the model, the test, shrinkage, multiple testing, enrichment, and the report in one answer. " +
         "Use `differential_expression` when the research question does not ask for pathways or gene sets; an enrichment step the user did not ask for is unasked scope. " +
         "Use `enrichment` when a results table is the input and no new test is fitted, and `qc` when the question stops at the sample structure. " +
         "Use `tf_activity` for regulator or pathway activity, `deconvolution` for cell type proportions, `coexpression` for modules, `clustering` for sample subgroups, `survival` for an outcome association, " +
-        "and `signature_scoring` for a per-sample score, or with `classifier: true` for a classifier of the samples."),
-    modality: z.literal("bulk_rna_seq").describe("The assay. Phase 0 serves bulk RNA-seq only."),
+        "and `signature_scoring` for a per-sample score, or with `classifier: true` for a classifier of the samples. " +
+        "Use `dose_response` when the question asks at which exposure the expression leaves the control: the walk fits a curve per gene over the dose, takes the benchmark dose of each gene set, " +
+        "reads the transcriptomic point of departure from the lowest set median, and divides it by an efficacious exposure for the exposure margin. " +
+        "A `dose_response` situation carries `n_dose_levels`, `tissue`, and `exposure_axis`, because the fit, the point of departure, and the margin each stop without one of them, " +
+        "and it carries `control_placement`, `grid_complete`, `recovery_group`, and `n_compounds` when the design holds them."),
+    modality: z
+        .enum(["bulk_rna_seq", "microarray", "tempo_seq"])
+        .describe("The platform that measured the expression: `bulk_rna_seq` for a sequencing run over the whole transcriptome; `microarray` for the probe intensities of a hybridization array, the platform of the legacy toxicogenomics compendia; " +
+        "`tempo_seq` for the targeted read counts of a TempO-Seq probe panel, where the panel and not the transcriptome is the gene universe. " +
+        "An array reads no sequence, thus it has no read count and no library size: a `microarray` takes `data_state` `log_normalized`, `de_results`, or `effect_sizes_only`, and `fastq`, `counts`, or `tpm_or_fpkm` stops the plan as a contradiction. " +
+        "A probe panel is a sequencing assay and it keeps the read count, thus `tempo_seq` takes `counts`; a panel gives no transcript length, thus never `tpm_or_fpkm`."),
     data_state: z
-        .enum(["fastq", "counts", "tpm_or_fpkm", "log_normalized"])
-        .describe("The state of the expression data in the inputs: raw reads, a raw integer count matrix, TPM/FPKM/RPKM abundances, or log-scale normalized values (log-CPM, microarray)."),
+        .enum(["fastq", "counts", "tpm_or_fpkm", "log_normalized", "de_results", "effect_sizes_only"])
+        .describe("The state of the expression data in the inputs: raw reads, a raw integer count matrix, TPM/FPKM/RPKM abundances, or log-scale normalized values (log-CPM, microarray). " +
+        "`de_results` is a table of contrasts with an effect size and a p-value per gene, and `effect_sizes_only` the same table with no p-value. " +
+        "A table of contrasts holds no value of a sample and no variance inside a dose group: without the p-values no step counts calls at a false discovery rate, and either table stops a benchmark dose fit."),
     count_source: z
         .enum(["salmon", "kallisto", "star_featurecounts", "rsem", "unknown"])
         .optional()
@@ -41,7 +53,9 @@ export const SituationFieldsSchema = z.object({
         "`corrected_counts`: a table described as lengthScaledTPM or scaledTPM counts. " +
         "`integer_counts`: integer counts from an aligner and a counter (STAR, featureCounts) or from a 3' protocol, with no length data. " +
         "`unknown`: a count table from a quantifier with no statement of the correction. Omit when `data_state` is not `counts`."),
-    organism: z.enum(["human", "mouse", "other"]).describe("The organism of the samples."),
+    organism: z
+        .enum(["human", "mouse", "rat", "dog", "monkey", "other"])
+        .describe("The organism of the samples. `rat`, `dog`, and `monkey` are the species of a regulatory toxicology study; use `other` only for a species this list does not name."),
     n_groups: z
         .number()
         .int()
@@ -71,10 +85,10 @@ export const SituationFieldsSchema = z.object({
         .describe("For a survival question, the number of samples with an observed event (event indicator 1) in the outcome column. Omit when the question is not survival or the count is not in the profile."),
     paired: z.boolean().describe("True when each subject contributes a sample to more than one condition (paired or repeated measures)."),
     blocking_factor: z
-        .enum(["individual", "cell_line", "litter", "site", "pair", "other"])
+        .enum(["individual", "cell_line", "litter", "site", "pair", "plate", "other"])
         .nullable()
         .optional()
-        .describe("The role of the blocking factor that is not the condition, never its column name: `individual` when the same subject, donor, or animal gives more than one sample; `cell_line`; `litter`; `site` for a center or a lab of a multi-site study; `pair` for matched pairs of different individuals; `other`. Omit when there is none. The column name stays in the step."),
+        .describe("The role of the blocking factor that is not the condition, never its column name: `individual` when the same subject, donor, or animal gives more than one sample; `cell_line`; `litter`; `site` for a center or a lab of a multi-site study; `pair` for matched pairs of different individuals; `plate` when the samples sit on culture or assay plates and one plate holds a set of them; `other`. Omit when there is none. The column name stays in the step."),
     block_structure: z
         .enum(["crossed", "nested"])
         .optional()
@@ -126,10 +140,14 @@ export const SituationFieldsSchema = z.object({
         "survival",
         "transcript_level",
         "annotation",
+        "reference_module_score",
+        "classifier_call",
     ]))
         .optional()
         .describe("Analyses the research question asks for beside the question kind, for example a regulator activity beside a differential expression. Each joins the procedure at its place. " +
-        "Add `annotation` when the rows of the count table are not gene symbols (Ensembl or Entrez identifiers) and a later step needs symbols: the identifier map is then a vetted step with its own template, and no other step rebuilds it. Omit when none."),
+        "Add `annotation` when the rows of the count table are not gene symbols (Ensembl or Entrez identifiers) and a later step needs symbols: the identifier map is then a vetted step with its own template, and no other step rebuilds it. " +
+        "Add `reference_module_score` for a score of each sample against a reference co-expression module set, and `classifier_call` for the call of a validated classifier on each sample. " +
+        "Each of the two contrasts two levels of the group column, thus either one needs two or more groups, a time course, or a numeric predictor. Omit when none."),
     preferred_language: z
         .enum(["R", "python"])
         .optional()
@@ -142,6 +160,60 @@ export const SituationFieldsSchema = z.object({
         .array(z.enum(["low_depth_sample", "outlier_sample", "sample_identity_doubt", "high_duplication", "degraded_rna"]))
         .optional()
         .describe("The quality concerns of the profile as typed flags: a sample with a library size far below the median; a sample that does not cluster with its group; a doubt about the identity of a sample; high duplication; degraded RNA (a low RNA integrity number, a 3' coverage bias, or formalin-fixed material)."),
+    tissue: z
+        .enum(["liver", "kidney", "heart", "muscle", "brain", "adipose", "blood", "other"])
+        .optional()
+        .describe("The tissue the samples come from: `liver`, `kidney`, `heart`, `muscle` for skeletal muscle, `brain` whole or one region, `adipose`, `blood` whole or a fraction, " +
+        "or `other` for a tissue this list does not name, for example a cell line. " +
+        "A transcriptomic point of departure belongs to the tissue of its samples, and the point of departure of one tissue says nothing about another, thus one call covers one tissue and the exposure margin stops without this field. " +
+        "Read it from the sample description of the profile or from the user request. Omit it when the question is not `dose_response`, or when the samples are not from one tissue."),
+    exposure_axis: z
+        .enum(["administered_dose", "in_vitro_concentration", "systemic_exposure"])
+        .optional()
+        .describe("The axis on which the exposure values of the study lie: `administered_dose` for the dose the study gives to the animal or to the culture, for example in mg/kg; " +
+        "`in_vitro_concentration` for the concentration of the compound in the medium of a cell culture; `systemic_exposure` for a measured level in the plasma, for example a Cmax or an AUC. " +
+        "The exposure margin divides the point of departure by an efficacious exposure, and that quotient means something only when both values lie on one axis and in one unit. " +
+        "Thus the margin stops without this field, and `in_vitro_concentration` stops it too, because a concentration in a medium is no dose of an intact organism and the extrapolation from in vitro to in vivo comes first. " +
+        "Read it from the dose column of the profile or from the user request. Omit it when the question is not `dose_response`."),
+    n_dose_levels: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("The number of dose levels of the design, the control level included. The dose levels are groups of the design, thus this count is at most `n_groups`, " +
+        "unless `continuous_predictor` is `dose` and the dose itself, not a group, is the factor of interest. " +
+        "Three levels is the floor of the walk: the model families of the average hold three or more parameters, thus below three levels no gene and no gene set has a benchmark dose and the point of departure stops. " +
+        "Read it from the dose column of the profile. Omit it when the question is not `dose_response`."),
+    n_compounds: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("The number of compounds the study exposes the samples to. One call covers one compound: no design term names a compound as a factor, and the point of departure and the exposure margin each give one value for one compound. " +
+        "Thus 2 or more says that the plan runs the walk one time for each compound, each run over the samples of that compound and the control samples of that compound, and it pools no two compounds in one fit. " +
+        "Read it from the sample table of the profile. Omit it when the question is not `dose_response`."),
+    control_placement: z
+        .enum(["single_baseline", "per_time", "per_block", "per_time_and_block"])
+        .optional()
+        .describe("Where the control samples sit in the design, which decides the samples that form the contrast of each treated sample: `single_baseline` when one control group serves every treated group; " +
+        "`per_time` when each time point holds its own control group; `per_block` when each block, for example a plate, holds its own control group; `per_time_and_block` for both. " +
+        "With a control at each time the design takes the dose and the time as fixed factors and the control of the same time as the reference level, so that a time effect all dose levels share leaves the dose contrast. " +
+        "`per_time` and `per_time_and_block` need `n_timepoints` or `continuous_predictor: time`, and `per_block` and `per_time_and_block` need `blocking_factor`. " +
+        "Read it from the sample table of the profile. Omit it when the question is not `dose_response`."),
+    grid_complete: z
+        .boolean()
+        .optional()
+        .describe("Whether every cell of the grid of the dose levels, the times, and the blocks holds at least one sample. Set false when a cell holds none: a model that assumes every cell, " +
+        "for example a cell-means model with one coefficient per combination or a full interaction of the factors, then carries a coefficient with no data and the design matrix loses rank. " +
+        "The plan then fits the terms the design can estimate and states the estimable contrasts only. " +
+        "Read it from the sample table of the profile. Omit it when every cell holds a sample."),
+    recovery_group: z
+        .boolean()
+        .optional()
+        .describe("Set true when the study holds a group that it observes after the exposure ends, for example animals that rest after the last dose. " +
+        "Such a group carries no dose at the time of its sample, thus it lies at no point of the dose-response curve and the fit leaves it out; " +
+        "a recovery sample placed at the dose of its exposure makes the response of that dose lower than the exposure gives. " +
+        "Read it from the time column or the group labels of the sample table. Omit it when the study samples every group during the exposure."),
 });
 /** The situation as the client sends it: the fields as given, with the caller preference held out of the situation fields. */
 export function toSituation(fields) {

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

@@ -19,6 +19,13 @@
  * one enrichment step on its own track, and one report step. A group with
  * no step in the procedure is absent from the skeleton.
  *
+ * A step whose own template reads the output of another template gets its
+ * own group, because a fold keeps the template of the central step alone and
+ * it would drop the others. Thus the four steps of the dose-response chain
+ * (the benchmark dose of each gene, the benchmark dose of each gene set, the
+ * point of departure, and the exposure margin) are four groups of one track,
+ * in that order, and each of the other four new steps is a group of its own.
+ *
  * The central step of a group names the method of the skeleton step, and it
  * gives the alternatives, the template, and the environment: an alternative
  * of a folded step (a normalization in the differential expression group)

package/dist/tools/knowledge/skeleton.js

@@ -19,6 +19,13 @@
  * one enrichment step on its own track, and one report step. A group with
  * no step in the procedure is absent from the skeleton.
  *
+ * A step whose own template reads the output of another template gets its
+ * own group, because a fold keeps the template of the central step alone and
+ * it would drop the others. Thus the four steps of the dose-response chain
+ * (the benchmark dose of each gene, the benchmark dose of each gene set, the
+ * point of departure, and the exposure margin) are four groups of one track,
+ * in that order, and each of the other four new steps is a group of its own.
+ *
  * The central step of a group names the method of the skeleton step, and it
  * gives the alternatives, the template, and the environment: an alternative
  * of a folded step (a normalization in the differential expression group)
@@ -40,6 +47,21 @@ const GROUPS = [
         steps: ["filter_low_counts", "normalize", "model_design", "differential_expression", "shrink_lfc", "multiple_testing"],
         name: "Differential expression",
     },
+    // The dose-response chain: each step reads the table that the step before
+    // it writes, thus the four are one track in the order of the chain. The
+    // track is its own, because the chain is a branch off the test and not a
+    // part of the core walk, and it ends in a regulatory quantity.
+    { id: "T4S1", track: "T4", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["dose_response_fit"], name: "Benchmark dose of each gene" },
+    {
+        id: "T4S2",
+        track: "T4",
+        step_type: "analysis",
+        agent: "bulk-transcriptomics-agent",
+        steps: ["benchmark_dose_sets"],
+        name: "Benchmark dose of each gene set",
+    },
+    { id: "T4S3", track: "T4", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["point_of_departure"], name: "Point of departure" },
+    { id: "T4S4", track: "T4", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["exposure_margin"], name: "Exposure margin" },
     { id: "T2S1", track: "T2", step_type: "enrichment", agent: "enrichment-agent", steps: ["enrichment"], name: "Gene set enrichment" },
     {
         id: "T2S2",
@@ -49,12 +71,45 @@ const GROUPS = [
         steps: ["tf_activity", "pathway_activity"],
         name: "Regulator and pathway activity",
     },
+    // The connectivity reads the contrast of the study against a reference
+    // resource, which is the shape and the agent of this track. The resource
+    // is a compendium of contrasts and not a gene set collection, thus the
+    // step is a group of its own beside the enrichment and the activity.
+    {
+        id: "T2S3",
+        track: "T2",
+        step_type: "analysis",
+        agent: "enrichment-agent",
+        steps: ["compendium_connectivity"],
+        name: "Compendium connectivity",
+    },
     { id: "T1S4", track: "T1", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["variance_partition"], name: "Variance partition" },
     { id: "T3S1", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["signature_scoring"], name: "Signature scoring" },
     { id: "T3S2", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["deconvolution"], name: "Cell type deconvolution" },
     { id: "T3S3", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["coexpression"], name: "Co-expression modules" },
     { id: "T3S4", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["clustering"], name: "Sample clustering" },
     { id: "T3S5", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["survival"], name: "Outcome association" },
+    // Three computations over the value matrix and the sample table, each
+    // independent of the others and of the chain, thus each is a group of
+    // this track: a class per gene over the time points, a score per sample
+    // against a reference module set, and a call per sample.
+    {
+        id: "T3S6",
+        track: "T3",
+        step_type: "analysis",
+        agent: "bulk-transcriptomics-agent",
+        steps: ["trajectory_classification"],
+        name: "Trajectory classification",
+    },
+    {
+        id: "T3S7",
+        track: "T3",
+        step_type: "analysis",
+        agent: "bulk-transcriptomics-agent",
+        steps: ["reference_module_score"],
+        name: "Reference module score",
+    },
+    { id: "T3S8", track: "T3", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["classifier_call"], name: "Classifier call" },
     { id: "T1S5", track: "T1", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["transcript_level"], name: "Transcript-level analysis" },
     { id: "T1S6", track: "T1", step_type: "analysis", agent: "bulk-transcriptomics-agent", steps: ["annotation"], name: "Identifier annotation" },
     { id: "T1S3", track: "T1", step_type: "report", agent: "bulk-transcriptomics-agent", steps: ["report"], name: "Report" },
@@ -63,23 +118,54 @@ const GROUPS = [
  * The dependencies of each group. The QC depends on the cohort assembly when
  * one is present, a group depends on the QC, on the differential expression
  * when its input is a results table, and the report depends on every group
- * that is present.
+ * that is present. A step of the dose-response chain depends on the step
+ * whose table it reads: the fit reads the genes that passed the test, the
+ * gene sets read the gene table of the fit, the point of departure reads the
+ * set table and the gene table, and the margin reads the point of departure.
  */
 const DEPENDS = {
     T0S1: [],
     T1S1: ["T0S1"],
     T1S2: ["T1S1"],
+    T4S1: ["T1S2"],
+    T4S2: ["T4S1"],
+    T4S3: ["T4S2", "T4S1"],
+    T4S4: ["T4S3"],
     T2S1: ["T1S2"],
     T2S2: ["T1S2", "T1S1"],
+    T2S3: ["T1S2"],
     T1S4: ["T1S1"],
     T3S1: ["T1S1"],
     T3S2: ["T1S1"],
     T3S3: ["T1S1"],
     T3S4: ["T1S1"],
     T3S5: ["T3S1", "T1S1"],
+    T3S6: ["T1S1"],
+    T3S7: ["T1S1"],
+    T3S8: ["T1S1"],
     T1S5: ["T1S1"],
     T1S6: ["T1S1"],
-    T1S3: ["T1S2", "T2S1", "T2S2", "T1S4", "T3S1", "T3S2", "T3S3", "T3S4", "T3S5", "T1S5", "T1S6"],
+    T1S3: [
+        "T1S2",
+        "T4S1",
+        "T4S2",
+        "T4S3",
+        "T4S4",
+        "T2S1",
+        "T2S2",
+        "T2S3",
+        "T1S4",
+        "T3S1",
+        "T3S2",
+        "T3S3",
+        "T3S4",
+        "T3S5",
+        "T3S6",
+        "T3S7",
+        "T3S8",
+        "T1S5",
+        "T1S6",
+    ],
 };
 /** A parameter value as a setting: a scalar stays, a list becomes a list of strings, anything else its text. */
 function settingValue(value) {

package/dist/tools/knowledge/template.js

@@ -124,6 +124,7 @@ export function createKnowledgeTemplateTool(deps) {
             "A change the slots do not cover: use `edit_file` on a line marked `# [adaptable: ...]` in the rendered script, and keep the edit small; the record lists each such edit. " +
             "`match: unavailable` means the service did not answer, and `match: snapshot_mismatch` means the service moved to another release than the plan pinned; in both cases write the script yourself as you would without this tool, and state it in your summary.",
         inputSchema: KnowledgeTemplateInputSchema,
+        view: "none",
         describeCall: ({ template }) => template,
         describeResult: (_input, result) => "status" in result ? (result.status === "ok" ? `${result.script_path} (${result.environment_match})` : result.status) : result.match,
         execute: async ({ template, slots, overrides, script_name }, ctx) => {

package/dist/tools/memory/update-working-memory.js

@@ -165,6 +165,11 @@ export function createUpdateWorkingMemoryTool(workingMemory, pool, opts = DEFAUL
             "user's last message, run contents (tables, gene lists, file paths), or anything you can retrieve " +
             "again with inspect_run, read_file, or search.",
         inputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // Four writes in one turn are four identical chips without this. The
         // entry id rides along on revise/retire because it is the only thing
         // separating two retirements from the same section.

package/dist/tools/read-tool-output.js

@@ -122,6 +122,10 @@ export function createReadToolOutputTool(store) {
             `${MAX_MATCHES} matches, each with its offset and the text around it. When a result gives \`more: true\`, ` +
             "call again with `offset` set to its `end`.",
         inputSchema: ReadToolOutputInputSchema,
+        view: {
+            input: (input) => input,
+            error: true,
+        },
         // The reference alone repeats across the pages of one text, and the pattern is what tells two searches apart.
         describeCall: ({ ref, pattern }) => (pattern === undefined ? ref : `${pattern} in ${ref}`),
         execute: async ({ ref, offset = 0, limit, pattern }, ctx) => {

package/dist/tools/report-authoring/authoring-tools.js

@@ -524,6 +524,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "A reference names the path of a pinned artifact, and the session stamps the hash from the pinned evidence.",
         inputSchema: addBlockInput,
         outputSchema: MutationOutputSchema,
+        view: "none",
         describeCall: (input) => {
             const block = decodeBlockPayload(input.block);
             const kind = readKind(block);
@@ -559,6 +560,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "A reference names the path of a pinned artifact, and the session stamps the hash from the pinned evidence.",
         inputSchema: changeBlockInput,
         outputSchema: MutationOutputSchema,
+        view: "none",
         describeCall: (input) => `change ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -582,6 +584,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
         description: "Remove one block by its id. A removed section takes its whole subtree with it, and the id is free for a later add.",
         inputSchema: removeBlockInput,
         outputSchema: MutationOutputSchema,
+        view: "none",
         describeCall: (input) => `remove ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -602,6 +605,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "A section cannot move into its own subtree.",
         inputSchema: moveBlockInput,
         outputSchema: MutationOutputSchema,
+        view: "none",
         describeCall: (input) => `move ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -622,6 +626,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
         description: "Set the title of the whole report, not the title of a section. A draft starts with no title, and a document needs one.",
         inputSchema: setTitleInput,
         outputSchema: MutationOutputSchema,
+        view: "none",
         describeCall: (input) => `title the report ${input.title}`,
         // The title sits on the document, thus no container changes its child order.
         execute: async (input, ctx) => {
@@ -648,6 +653,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "and read one block when the label is not enough.",
         inputSchema: readOutlineInput,
         outputSchema: OutlineOutputSchema,
+        view: "none",
         // The input carries no field, thus a hook can only restate the name of the tool.
         describeCall: "none",
         execute: async (_input, ctx) => {
@@ -665,6 +671,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "because the outline already names every block under it. Use it when the outline label is not enough.",
         inputSchema: readBlockInput,
         outputSchema: ReadBlockOutputSchema,
+        view: "none",
         describeCall: (input) => `read ${input.targetId}`,
         execute: async (input, ctx) => {
             const opened = await openThread(ctx);
@@ -685,6 +692,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "preview_report and record_report_version run the same check before they act, thus a finish directly before one of them does that check a second time. " +
             "Use it to make sure that the draft passes the whole document schema, the id rule, and the structural tier.",
         inputSchema: finishDraftInput,
+        view: "none",
         // The input carries no field, thus a hook can only restate the name of the tool.
         describeCall: "none",
         execute: async (_input, ctx) => {

package/dist/tools/report-session/examine-page.js

@@ -254,6 +254,11 @@ export function createExaminePageTool(deps) {
             "The outcomes no-page and missed-stamp mean that no preview rendered the current page: run preview_report, then look again. " +
             "The outcome no-browser means that this host gives no browser, and a repeat gives the same outcome.",
         inputSchema: examinePageInput,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: (input) => {
             const blockId = input.blockId ?? undefined;
             return blockId === undefined ? "look at the page" : `look at ${blockId}`;

package/dist/tools/report-session/list-artifacts.js

@@ -148,6 +148,11 @@ export function createListPinnedArtifactsTool(deps) {
             "Read the listing to orient before you bind a block. Read the columns of one artifact to choose the column that a locator names. " +
             "A reference names the path alone: the session stamps the hash from this evidence, thus the tool gives no hash.",
         inputSchema: listPinnedArtifactsInput,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         describeCall: (input) => input.path ?? "the pinned set",
         // The size of the listing is what a watcher reads, and the cap makes that size differ from the
         // pinned set. Thus a truncated listing names the total beside the count, and a whole listing names

package/dist/tools/report-session/preview-report.js

@@ -376,6 +376,7 @@ export function createPreviewReportTool(deps) {
             "The render marks the page that examine_page looks at next. " +
             "Use it to see the report, and to confirm that each reference resolves.",
         inputSchema: previewReportInput,
+        view: "none",
         describeCall: "none",
         // The page path is the one fact of a preview that a watcher wants, and it exists only in the
         // result. Each other arm is a degraded condition whose kind already names it, thus the kind

package/dist/tools/report-session/record-version.js

@@ -138,6 +138,7 @@ export function createRecordVersionTool(deps) {
             "A thread holds one version, thus a later record replaces it whole. Amend the draft, look at the page again, and record again. " +
             "After the version lands, the tool removes the file of each derived table that no block of the recorded report binds.",
         inputSchema: recordVersionInput,
+        view: "none",
         describeCall: "none",
         // The version id is the one durable product of the first record, thus the created arm names it. A
         // later record writes over that same id, thus the line names the update and never reads as a

package/dist/tools/report-session/script-tools.js

@@ -40,6 +40,7 @@ function createReadTableTool(deps) {
             "A larger table does not derive; tell the user which table is absent.",
         inputSchema: readTableInput,
         outputSchema: ReadTableOutputSchema,
+        view: "none",
         describeCall: ({ path }) => path,
         describeResult: (_input, result) => `${String(result.rowCount)} rows`,
         execute: async ({ path, columns }, ctx) => {
@@ -100,6 +101,7 @@ function createWriteDerivedTool(deps) {
             "Name each pinned table that the script read in `inputs`. A name that this session already holds is refused, thus a second derivation of one table takes a new name.",
         inputSchema: writeDerivedInput,
         outputSchema: DerivedOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, rows, inputs }, ctx) => {

package/dist/tools/research/context7-docs.js

@@ -51,6 +51,7 @@ export const resolveLibraryIdTool = defineTool({
         libraryName: z.string().describe("Package or library name to search for (e.g., 'scanpy', 'pysam', 'lifelines')."),
         query: z.string().describe("What you need help with — used to rank results by relevance (e.g., 'how to run differential expression')."),
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ libraryName, query }) => {
         const result = await apiFetchValidated(`${CONTEXT7_BASE}/search?query=${encodeURIComponent(libraryName)}&topic=${encodeURIComponent(query)}`, Context7SearchResponseSchema, { maxRetries: 1 });
@@ -80,6 +81,7 @@ export const queryDocsTool = defineTool({
         libraryId: z.string().describe("Context7 library ID exactly as `resolve_library_id` gave it — an owner and a library, for example '/scverse/scanpy'."),
         query: z.string().describe("Specific question about the library (e.g., 'rank_genes_groups function parameters and usage')."),
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ libraryId, query }) => {
         // The library id is the path of the route, not a query parameter. Each

package/dist/tools/research/generate-analogy-report.js

@@ -47,6 +47,7 @@ function createRecordProblemTool() {
         description: "Record the extraction of phase 1: the problem summary, objects, relations, key terms, and the analogies " +
             "that phase 2 searches. A later call replaces the record.",
         inputSchema: RecordProblemInputSchema,
+        view: "none",
         describeCall: "none",
         execute: () => Promise.resolve(ok({ recorded: true })),
     });
@@ -57,6 +58,7 @@ function createRecordAnalogyTool() {
         description: "Record one analogy with its coverage and its cited solutions, when its search is done. A later call " +
             "with the same analogyTitle replaces the record.",
         inputSchema: AnalogySchema,
+        view: "none",
         describeCall: ({ analogyTitle }) => analogyTitle,
         execute: () => Promise.resolve(ok({ recorded: true })),
     });
@@ -268,6 +270,7 @@ export function createGenerateAnalogyReportTool(deps, registerSubAgent) {
             "A retry with the same or a similar problem statement meets the same " +
             "failure, thus surface the message and ask the user to narrow the problem.",
         inputSchema: generateAnalogyReportInputSchema,
+        view: "none",
         describeCall: "none",
         startsWorkflow: true,
         execute: async (input, ctx) => ok(await research(input, ctx)),

package/dist/tools/research/generate-plan.js

@@ -602,6 +602,7 @@ function buildInnerTools(logger, memory) {
             // structured issue reporting.
             plan: z.union([PlannerPlanSchema, z.unknown()]).describe("Candidate plan; malformed values are reported in issues."),
         }),
+        view: "none",
         describeCall: "none",
         execute: (input) => {
             // The host owns the grounding fields: it fills them from the last answer of the run.
@@ -639,6 +640,7 @@ function buildInnerTools(logger, memory) {
             question: terminalTextSchema("One short question that names each missing fact, and the step that needs it."),
             questionContext: z.string().optional().describe("Optional context: why the plan needs the fact, and what the inputs already say about it."),
         }),
+        view: "none",
         describeCall: "none",
         execute: (input) => Promise.resolve(ok({
             kind: "clarification",
@@ -1181,6 +1183,10 @@ export function createGeneratePlanTool(deps, registerSubAgent) {
             "when the planner is missing a fact it cannot infer; or `error` with {error} when no plan was saved (the planner reported " +
             "a blocker, the save failed, the call timed out or was cancelled, or parentPlanId is not a plan of this analysis).",
         inputSchema: generatePlanInputSchema,
+        view: {
+            input: (input) => input,
+            error: true,
+        },
         describeCall: ({ researchQuestion }) => researchQuestion,
         startsWorkflow: true,
         execute: async (input, ctx) => {

package/dist/tools/research/inspect-data-profile.js

@@ -136,6 +136,11 @@ export function createInspectDataProfileTool(pool) {
             "against when the input set last changed before you conclude anything: if the data moved since, say the profile " +
             "needs re-running rather than diagnosing the data itself.",
         inputSchema: InspectDataProfileInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // `execute` defaults both fields internally, and the hook applies the same
         // defaults. Without them the ordinary call, which names no field at all,
         // gives no detail. `page` acts only on the `files` scope, as in `execute`.

package/dist/tools/research/inspect-run.js

@@ -109,6 +109,11 @@ export function createInspectRunTool(pool, clock = systemClock) {
             "For a user-directed check, waitForTerminalSeconds can wait once for 1-30 seconds; if the cutoff returns in_progress, stop polling for that turn and tell the user that the run still runs. " +
             "Default response is lightweight — pass includeDiagnostics:true to add error/duration/retry telemetry.",
         inputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // The two calls do different work: one inspects a named run, the other
         // pages the list. Naming the run id is what separates repeated polls of
         // the same run from polls of different ones.

package/dist/tools/research/resolve-citation.js

@@ -14,6 +14,7 @@ export function createResolveCitationTool(resolver) {
             "not_found, unverifiable, or inconclusive. Source failure never becomes not_found — an unreachable authority reports unavailable, and " +
             "not_found means the authorities that answered hold no such record.",
         inputSchema: CitationInputSchema,
+        view: "none",
         describeCall: ({ citation }) => `verify ${citation}`,
         execute: async (input, ctx) => ok(await resolver.resolveOne(input, { signal: ctx.signal })),
     });

package/dist/tools/research/search-arxiv.js

@@ -39,6 +39,7 @@ export const searchArxivTool = defineTool({
             "and that filter is combined with the query using AND."),
         limit: z.number().int().min(1).max(20).default(10).describe("Maximum results (1–20, default 10)."),
     }),
+    view: "none",
     describeCall: "none",
     execute: async ({ query, categories, limit }, context) => {
         const result = await source.search({ query, categories, limit }, context.signal);

package/dist/tools/research/search-github-repos.js

@@ -87,6 +87,7 @@ export function createSearchGithubReposTool(deps) {
             "lands here). Report either one and continue, do not retry unchanged.",
         outputSchema: SearchGithubReposOutputSchema,
         inputSchema: SearchGithubReposInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ query, language, limit }) => {
             const q = language ? `${query} language:${language}` : query;

package/dist/tools/research/search-semantic-scholar.js

@@ -46,6 +46,7 @@ export function createSearchSemanticScholarTool(options = {}) {
                 '"reinforcement learning for control" or "feedback stabilisation in oscillators".'),
             limit: z.number().int().min(1).max(20).default(10).describe("Maximum number of results to return (1–20, default 10)."),
         }),
+        view: "none",
         describeCall: "none",
         execute: async ({ query, limit }, context) => {
             const result = await source.search(query, limit, context.signal);

package/dist/tools/research/web-fetch.js

@@ -614,6 +614,7 @@ export function createWebFetchTool(deps = {}) {
             "private, link-local, or reserved), http_error, redirect_limit, body_too_large, unextractable, and request_failed each name what " +
             "happened. Report the status and continue, do not retry unchanged.",
         inputSchema: WebFetchInputSchema,
+        view: "none",
         describeCall: ({ url }) => url,
         execute: async ({ url }, ctx) => ok(await fetchOneUrl(url, deps, ctx)),
     });

package/dist/tools/research/web-search.js

@@ -77,6 +77,7 @@ export function createWebSearchTool(deps) {
             "ABSENCE IS NORMAL: an empty results array means no page matched, and a status of http_error, retryable_status, " +
             "schema_mismatch, or not_json names a search that did not answer. Report either one and continue, do not retry unchanged.",
         inputSchema: WebSearchInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ query, queries, numResults, recencyFilter, domainFilter }) => {
             const filter = parseDomainFilter(domainFilter);

package/dist/tools/sandbox/lease-tools.js

@@ -24,6 +24,7 @@ export function createAcquireSandboxTool(lease) {
             "size replaces your sandbox: the files of your working directory stay, and the next command runs on the new " +
             "size. Your files and your outputs live in the workspace, not in the sandbox.",
         inputSchema: AcquireSandboxInputSchema,
+        view: "none",
         describeCall: ({ cpu, memoryGb }) => `Waiting for a sandbox (${cpu} CPU, ${memoryGb} GB)`,
         execute: async ({ cpu, memoryGb, gpuCount }) => {
             const size = gpuCount === undefined || gpuCount === 0 ? { cpu, memoryGb } : { cpu, memoryGb, gpu: { count: gpuCount } };
@@ -51,6 +52,7 @@ export function createReleaseSandboxTool(lease) {
         description: "Release your sandbox when your commands are done and you work only with files or research. The files stay. " +
             "A later `execute_command` needs `acquire_sandbox` again.",
         inputSchema: ReleaseSandboxInputSchema,
+        view: "none",
         describeCall: () => "Releasing the sandbox",
         execute: async () => {
             await lease.release();