@inflexa-ai/harness 0.48.1 → 0.48.2

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();

package/dist/tools/sandbox/link-packages.js

@@ -70,6 +70,7 @@ export function createLinkPackagesTool(deps) {
             "After a `collision` of one name that BOTH tracks hold, call this tool again for that package with the prefixed form, `python:<name>` or `r:<name>`. " +
             "A collision is terminal only after that second call also refuses, or when it names two versions of one distribution — then report it and continue without the package.",
         inputSchema: LinkPackagesInputSchema,
+        view: "none",
         describeCall: ({ packages }) => packages.join(", "),
         execute: async (input) => {
             // Every entry parses before any link lands. A partial link over a

package/dist/tools/sandbox/list-available-packages.js

@@ -495,6 +495,11 @@ export function createListAvailablePackagesTool(deps = {}) {
             "`limit`: cap the packages listed; the response always carries the true `total` and a `hasMore` flag, so truncation is never silent. " +
             "Each entry renders as `name==version` where the source pins a version, and a `names` check also reports the store directory and the content hash where the source records them.",
         inputSchema: ListAvailablePackagesInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // `queryPackages` returns on `names` before it reads another field, thus
         // the presence check comes first. An empty array is not a presence check.
         // `names` are exact identifiers a caller checks for, thus they name the

package/dist/tools/sandbox/list-available-refs.js

@@ -600,6 +600,11 @@ export function createListAvailableRefsTool(deps) {
             "An empty result means the dataset is absent right now — not that it is unobtainable. Say so; never guess a path, and never silently substitute a different dataset. " +
             "The store is provisioned by the host and is NOT frozen: datasets can be added through the host's own provisioning path between runs, and whatever is added shows up in a later run. Within one run the listing does not change, thus one call per question is enough.",
         inputSchema: ListAvailableRefsInputSchema,
+        view: {
+            input: (input) => input,
+            result: (_input, result) => result,
+            error: true,
+        },
         // `execute` resolves `path ?? category` for the subtree it inspects, and
         // it ignores `category` when `path` is present. `query` is an ADDITIVE
         // filter over that subtree, thus the target keeps naming the call and the

package/dist/tools/sandbox/report-blocker.js

@@ -37,6 +37,7 @@ export function createReportBlockerToolFor(deps) {
         id: REPORT_BLOCKER_TOOL_ID,
         description: `Terminal. ${deps.blockedWhen} Pass a clear reason. Stop immediately after calling — take no further actions.`,
         inputSchema: ReportBlockerInputSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => Promise.resolve(ok({ kind: "blocker", reason: input.reason, message: "Blocker recorded. You are done — stop now and do not take further actions." })),
     });

package/dist/tools/sandbox/skills.js

@@ -63,6 +63,7 @@ export function createSkillTools(deps) {
             "and the first line that holds a query word — ranked by how many distinct query words the file " +
             "holds. Then `skill_read` the file. No matches returns a data variant.",
         inputSchema: SkillSearchInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ query, topK }) => {
             if (allowed.size === 0) {
@@ -121,6 +122,7 @@ export function createSkillTools(deps) {
             "found via skill_search). Confined to your declared skills. Undeclared " +
             "skills and missing paths return a data variant.",
         inputSchema: SkillReadInputSchema,
+        view: "none",
         describeCall: "none",
         execute: async ({ skill, path }) => {
             if (!allowed.has(skill)) {

package/dist/tools/sandbox/submit-file-metadata.js

@@ -43,6 +43,7 @@ export function createSubmitFileMetadataTool(cell) {
             "accepted=true means every file now has metadata — STOP. Otherwise drop " +
             "the unknownPaths and describe the remaining files.",
         inputSchema: SubmitFileMetadataInputSchema,
+        view: "none",
         describeCall: "none",
         execute: (input) => {
             const knownPaths = cell.knownPaths;

package/dist/tools/script/file-tools.js

@@ -165,6 +165,7 @@ function createReadTableTool(deps) {
             "A larger table, or another format such as h5ad, is work for an analysis run.",
         inputSchema: readTableInput,
         outputSchema: ReadTableOutputSchema,
+        view: "none",
         describeCall: ({ path, entry }) => (entry === undefined ? path : `${path} : ${entry}`),
         describeResult: (_input, result) => `${String(result.rowCount)} rows`,
         execute: async ({ path, entry, columns }, ctx) => {
@@ -201,6 +202,7 @@ function createListArchiveTool(deps) {
             "`read_table` and `read_pdf` then read one of them as their `entry`.",
         inputSchema: listArchiveInput,
         outputSchema: ListArchiveOutputSchema,
+        view: "none",
         describeCall: ({ path }) => path,
         describeResult: (_input, result) => `${String(result.entries.length)} files`,
         execute: async ({ path }, ctx) => {
@@ -266,6 +268,7 @@ export function createReadPdfTool(deps) {
             "A scanned page with no text layer reads as an empty text.",
         inputSchema: readPdfInput,
         outputSchema: ReadPdfOutputSchema,
+        view: "none",
         describeCall: ({ path, entry, firstPage, lastPage }) => {
             const file = entry === undefined ? path : `${path} : ${entry}`;
             return firstPage === undefined && lastPage === undefined ? file : `${file}, pages ${String(firstPage ?? 1)}-${String(lastPage ?? "")}`;
@@ -359,6 +362,7 @@ function createWriteDerivedTool(deps) {
             "A name holds one file: a second write of the name with other content is refused.",
         inputSchema: writeDerivedInput,
         outputSchema: WrittenOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, content, rows }, ctx) => {
@@ -400,6 +404,7 @@ function createRenderChartTool(deps) {
             "To show a chart in the chat, use `show_user`.",
         inputSchema: renderChartInput,
         outputSchema: WrittenOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, spec, width }, ctx) => {
@@ -447,6 +452,7 @@ function createExportPdfTool(deps) {
             "Charts that `render_chart` wrote can appear in it as images. The PDF reads no URL.",
         inputSchema: exportPdfInput,
         outputSchema: ExportPdfOutputSchema,
+        view: "none",
         describeCall: ({ name }) => name,
         describeResult: (_input, result) => result.path,
         execute: async ({ name, markdown, title }, ctx) => {