@inflexa-ai/harness 0.46.2 → 0.48.0

package/dist/tools/bio/pubmed.js

@@ -116,6 +116,36 @@ const inputSchema = z
     message: "maxAuthors and maxMeshTerms apply to action 'details' only",
     path: ["action"],
 });
+const ArticleSummarySchema = z.object({ pmid: z.string(), title: z.string(), journal: z.string(), year: z.string(), authors: z.string() });
+const ArticleSchema = z.object({
+    pmid: z.string(),
+    title: z.string(),
+    abstract: z.string(),
+    authors: z.array(z.string()),
+    authorCount: z.number(),
+    journal: z.string(),
+    year: z.string(),
+    doi: z.string(),
+    meshTerms: z.array(z.string()),
+    meshTermCount: z.number(),
+    pmcId: z.string().nullable(),
+});
+const outputSchema = z.union([
+    z.object({ totalFound: z.number(), results: z.array(ArticleSummarySchema) }).describe("action 'search'"),
+    z.object({ articles: z.array(ArticleSchema), notFound: z.array(z.string()) }).describe("action 'details'"),
+    z.object({ pmcId: z.string(), available: z.literal(false) }).describe("action 'fulltext', not open access"),
+    z
+        .object({
+        pmcId: z.string(),
+        available: z.literal(true),
+        fullText: z.string(),
+        outline: z.array(z.object({ heading: z.string(), chars: z.number(), included: z.boolean() })),
+        totalChars: z.number(),
+        returnedChars: z.number(),
+        truncated: z.boolean(),
+    })
+        .describe("action 'fulltext'"),
+]);
 export function createPubMedTool(deps) {
     return defineTool({
         id: "pubmed",
@@ -132,6 +162,7 @@ export function createPubMedTool(deps) {
             "An empty result set and available: false are expected outcomes, not errors — an article with no PMC record simply has no open full text. " +
             "Report it and continue, do not retry it.",
         inputSchema,
+        outputSchema,
         // 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-gene.js

@@ -29,6 +29,22 @@ const NON_SYMBOL_PATTERNS = [/^ENSG\d{11}$/, /^HGNC:\d+$/, /^CHEMBL\d+$/, /^[A-Z
 function isSymbol(identifier) {
     return !NON_SYMBOL_PATTERNS.some((pattern) => pattern.test(identifier));
 }
+const SearchGeneOutputSchema = z.object({
+    genes: z.array(z.object({
+        symbol: z.string(),
+        id: z.string().describe("The Ensembl gene id (ENSG…), the key of the other gene lookups."),
+        displayName: z.string(),
+        description: z.string(),
+        biotype: z.string(),
+        start: z.number(),
+        end: z.number(),
+        strand: z.number(),
+        assemblyName: z.string(),
+        seqRegionName: z.string(),
+    })),
+    resolvedFrom: z.array(z.object({ input: z.string(), symbol: z.string() })),
+    notFound: z.array(z.string()),
+});
 export const searchGeneTool = defineTool({
     id: "search_gene",
     description: "Resolve gene identifiers against Ensembl — the identifier step other tools depend on. Per gene: Ensembl gene ID (ENSG…), coordinates, strand, " +
@@ -41,6 +57,7 @@ export const searchGeneTool = defineTool({
         "non-human `species` looks the ortholog up by the human approved symbol.\n" +
         "notFound is valid no-data (a deprecated, aliased or mistyped identifier, or one this species has no gene for) — report it and continue, do not " +
         "retry unchanged.",
+    outputSchema: SearchGeneOutputSchema,
     inputSchema: z.object({
         identifiers: z
             .array(z.string())

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

@@ -70,6 +70,18 @@ export function mapGeoDatasets(ids, summary) {
     }
     return datasets;
 }
+const SearchGeoDatasetsOutputSchema = z.object({
+    totalFound: z.number(),
+    datasets: z.array(z.object({
+        accession: z.string(),
+        title: z.string(),
+        summary: z.string(),
+        platform: z.string().nullable(),
+        sampleCount: z.number().nullable(),
+        organism: z.string().nullable(),
+        pubmedIds: z.array(z.union([z.string(), z.number()])),
+    })),
+});
 export const searchGeoDatasetsTool = defineTool({
     id: "search_geo_datasets",
     description: "Search the NCBI Gene Expression Omnibus (GEO) — the public functional-genomics repository of the U.S. National Library of Medicine — for " +
@@ -80,6 +92,7 @@ export const searchGeoDatasetsTool = defineTool({
         "HARD CAVEAT: this tool returns metadata only, and sandbox containers have no network — never plan an in-sandbox step that downloads a GEO dataset. " +
         "Bringing the data itself in is a capability of the surrounding environment, not of this tool: consult the tools you actually have rather than assuming it is possible or that it is not. " +
         "An empty datasets array is a valid 'nothing matched' — do not retry the identical query.",
+    outputSchema: SearchGeoDatasetsOutputSchema,
     inputSchema: z.object({
         query: z
             .string()

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

@@ -105,7 +105,7 @@ export function createSearchRegulatoryApprovalsTool(deps) {
             "ANDA), emaProductNumber, ndc (product or package code) or splSetId.\n" +
             "status 'not_found' is a valid no-data answer and status 'ambiguous' lists the candidate amassIds of an identifier that matches more " +
             "than one record — call 'details' again with one of them. An empty search is also valid no-data. Do not retry any of these unchanged.\n" +
-            "Requires AMASS_API_KEY — a missing key fails terminally: do NOT retry, tell the user the key needs configuring and proceed without " +
+            "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,
         describeCall: "none",

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

@@ -128,6 +128,13 @@ export type ToolContext = {
      * no child agent ignores it.
      */
     readonly turnUsage?: AgentRunUsage;
+    /**
+     * The script that makes this call, when `run_script` makes it. A tool that records how its output was made
+     * keeps the code, for example the derivation record of a report session. Absent for a call of the model.
+     */
+    readonly script?: {
+        readonly code: string;
+    };
 };
 /** What the approval hook of a tool reads of its call. */
 export type ToolApprovalContext = {
@@ -143,6 +150,10 @@ export type Tool<Input = unknown, Output = unknown> = {
     readonly description: string;
     readonly inputSchema: z.ZodType<Input>;
     readonly jsonSchema: Record<string, unknown>;
+    /** See {@link ToolDefinition.outputSchema}. Absent when the tool declares none. */
+    readonly outputSchema?: z.ZodType;
+    /** The JSON Schema of {@link outputSchema}. */
+    readonly outputJsonSchema?: Record<string, unknown>;
     /** See {@link ToolDefinition.describeCall}. Absent when the tool declares none. */
     describeCall?(input: Input): string | undefined;
     /** See {@link ToolDefinition.describeResult}. Absent when the tool declares none. */
@@ -156,12 +167,19 @@ export type Tool<Input = unknown, Output = unknown> = {
     approval?(input: Input, ctx: ToolApprovalContext): AskRequest | undefined | Promise<AskRequest | undefined>;
     /** See {@link ToolDefinition.startsWorkflow}. */
     readonly startsWorkflow?: boolean;
+    /** See {@link ToolDefinition.ownStep}. */
+    readonly ownStep?: boolean;
     execute(input: Input, ctx: ToolContext): Promise<Result<Output, ToolError>>;
 };
-export type ToolDefinition<Schema extends z.ZodType<z.output<Schema>>, Output> = {
+export type ToolDefinition<Schema extends z.ZodType<z.output<Schema>>, Output, OutputSchema extends z.ZodType = z.ZodType> = {
     readonly id: string;
     readonly description: string;
     readonly inputSchema: Schema;
+    /**
+     * The shape of the ok value. A script reads the value as data, thus `run_script` shows this type in the signature
+     * of the tool. The value of `execute` must hold each field of the schema, and it can hold more.
+     */
+    readonly outputSchema?: OutputSchema;
     /**
      * One line that names what THIS call does — the call-time counterpart of
      * `description`. `description` self-describes the tool at attach time, so an
@@ -251,6 +269,11 @@ export type ToolDefinition<Schema extends z.ZodType<z.output<Schema>>, Output> =
      * child before its first `await`, thus the parallel calls of one reply keep their order on a replay.
      */
     readonly startsWorkflow?: boolean;
+    /**
+     * The call must be one durable step of its own, for example an exec whose id comes from its step. Each call of
+     * a script runs inside the one step of the script, thus `withRunScript` refuses such a tool as a script tool.
+     */
+    readonly ownStep?: boolean;
     execute(input: z.infer<Schema>, ctx: ToolContext): Promise<Result<Output, ToolError>>;
 };
 /**
@@ -260,4 +283,4 @@ export type ToolDefinition<Schema extends z.ZodType<z.output<Schema>>, Output> =
  * the first LLM call). Union-shaped inputs must be modelled as a flat object
  * with a discriminator field.
  */
-export declare function defineTool<Schema extends z.ZodType<z.output<Schema>>, Output>(def: ToolDefinition<Schema, Output>): Tool<z.infer<Schema>, Output>;
+export declare function defineTool<Schema extends z.ZodType<z.output<Schema>>, Output extends z.output<OutputSchema>, OutputSchema extends z.ZodType = z.ZodType>(def: ToolDefinition<Schema, Output, OutputSchema>): Tool<z.infer<Schema>, Output>;

package/dist/tools/define-tool.js

@@ -111,13 +111,15 @@ export function defineTool(def) {
             `top-level "type" — model the input as a flat object with a ` +
             `discriminator field instead.`);
     }
-    const packaged = {
+    let packaged = {
         id: def.id,
         description: def.description,
         inputSchema: def.inputSchema,
         jsonSchema,
         execute: def.execute.bind(def),
     };
+    if (def.outputSchema !== undefined)
+        packaged = { ...packaged, outputSchema: def.outputSchema, outputJsonSchema: outputJsonSchemaOf(def.outputSchema) };
     if (typeof def.foldCallRecord === "function")
         packaged.foldCallRecord = def.foldCallRecord.bind(def);
     if (typeof def.approval === "function")
@@ -133,7 +135,15 @@ export function defineTool(def) {
     // property check on either side.
     if (def.describeResult !== undefined)
         packaged.describeResult = def.describeResult;
+    if (def.ownStep === true)
+        packaged = { ...packaged, ownStep: true };
     if (def.startsWorkflow === true)
         return { ...packaged, startsWorkflow: true };
     return packaged;
 }
+/** The JSON Schema of an ok value, as a reader of the value sees it. */
+function outputJsonSchemaOf(schema) {
+    const json = z.toJSONSchema(schema, { io: "output", unrepresentable: "any" });
+    delete json.$schema;
+    return json;
+}

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

@@ -41,7 +41,7 @@ const ShowUserInputSchema = z.object({
     dataPath: z
         .string()
         .optional()
-        .describe("echart only: analysis-rooted CSV artifact path (e.g. 'runs/run-abc/step-2/output/de-summary.csv') the host loads as the ECharts `dataset.source` at render time. Author `encode`/dimensions against the CSV's column names (read only its header) and omit `dataset.source` from the spec — the rows are never pulled through the context window. The tool checks the shape of the path only, not that the file exists; a wrong path fails only when the card renders. If the data is not chart-ready (needs aggregation, filtering, reshaping), do that in a sandbox step that writes a chart-ready CSV. Inline `dataset.source` is only for a handful of numbers you just computed in conversation that exist nowhere as an artifact."),
+        .describe("echart only: analysis-rooted CSV artifact path (e.g. 'runs/run-abc/step-2/output/de-summary.csv') the host loads as the ECharts `dataset.source` at render time. Author `encode`/dimensions against the CSV's column names (read only its header) and omit `dataset.source` from the spec — the rows are never pulled through the context window. The tool checks the shape of the path only, not that the file exists; a wrong path fails only when the card renders. If the data is not chart-ready (it needs an aggregate, a filter, or a reshape), make a chart-ready CSV with `run_script` (`read_table`, then `write_derived`), and pass its path. Inline `dataset.source` is only for a handful of numbers you just computed in conversation that exist nowhere as an artifact."),
     body: z.string().optional().describe("Markdown content to render (kind=markdown)"),
     code: z.string().optional().describe("Code content (kind=code)"),
     language: z.string().optional().describe("Language identifier, e.g. r, python, bash (kind=code)"),

package/dist/tools/execute-analysis.d.ts

@@ -9,7 +9,6 @@ import { z } from "zod";
 import type { AgentSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { EnvironmentStorePaths } from "../config/environment-stores.js";
-import type { ResourcePolicy } from "../config/resource-limits.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { RunLauncher } from "../execution/run-launcher.js";
 import type { Logger } from "../lib/logger.js";
@@ -33,7 +32,6 @@ export type ExecuteAnalysisToolDeps = Pick<EnvironmentStorePaths, "farmLockFile"
     readonly executeAnalysisWorkflow: ExecuteAnalysisWorkflow;
     readonly runAuthorizer: RunAuthorizer;
     readonly runLauncher: RunLauncher;
-    readonly resourcePolicy?: ResourcePolicy;
     readonly utilityProvider: ChatProvider;
     readonly utilityModel: string;
     readonly logger?: Logger;
@@ -78,7 +76,7 @@ export declare class PlanReferencesMissingError extends Error {
     constructor(missing: string[], unavailable?: string | undefined);
 }
 /** The deps that start the run of a stored plan. */
-export type LaunchPlanRunDeps = Pick<ExecuteAnalysisToolDeps, "pool" | "executeAnalysisWorkflow" | "runAuthorizer" | "runLauncher" | "resourcePolicy" | "extendAnalysisFarm" | "refStorePath" | "logger">;
+export type LaunchPlanRunDeps = Pick<ExecuteAnalysisToolDeps, "pool" | "executeAnalysisWorkflow" | "runAuthorizer" | "runLauncher" | "extendAnalysisFarm" | "refStorePath" | "logger">;
 /**
  * The run of a stored plan. `started` is false when this call started nothing: `runId` then names the
  * active run of the plan, or the newest run of the plan when the view of the caller was stale.

package/dist/tools/execute-analysis.js

@@ -51,20 +51,20 @@ const inputSchema = z
 });
 export class PlanNotFoundError extends Error {
     constructor(planId) {
-        super(`Plan ${planId} not found for this analysis`);
+        super(`Plan ${planId} not found for this analysis. Generate a new plan; a retry of this planId fails the same way.`);
         this.name = "PlanNotFoundError";
     }
 }
 export class PlanMalformedError extends Error {
     constructor(planId) {
-        super(`Plan ${planId} is malformed`);
+        super(`Plan ${planId} is malformed. Generate a new plan; a retry of this planId fails the same way.`);
         this.name = "PlanMalformedError";
     }
 }
 export class PlanValidationError extends Error {
     errors;
     constructor(planId, errors) {
-        super(`Plan ${planId} failed validation: ${errors.length} error(s)`);
+        super(`Plan ${planId} failed validation: ${errors.length} error(s). Generate a new plan; a retry of this planId fails the same way.`);
         this.errors = errors;
         this.name = "PlanValidationError";
     }
@@ -243,25 +243,6 @@ async function linkPlanPackages(extendAnalysisFarm, analysisId, planId, plan) {
 function planSummary(plan) {
     return plan.title?.trim() || plan.analytical_narrative.trim().slice(0, 280);
 }
-/**
- * The resources of each step. `validatePlan` refuses a step without them, thus
- * a missing entry here means that the two readers disagree.
- */
-function stepResources(planId, plan) {
-    const byStepId = {};
-    for (const step of plan.steps) {
-        if (!step.resources) {
-            return err({
-                type: "plan_invalid",
-                planId,
-                malformed: false,
-                errors: [`Step "${step.id}" has no resources — validation should have rejected it`],
-            });
-        }
-        byStepId[step.id] = step.resources;
-    }
-    return ok(byStepId);
-}
 function workflowInput(planId, plan, args) {
     return {
         analysisId: args.analysisId,
@@ -270,10 +251,8 @@ function workflowInput(planId, plan, args) {
         threadId: args.threadId,
         steps: plan.steps.map((step) => ({ id: step.id, depends_on: step.depends_on })),
         planStepById: Object.fromEntries(plan.steps.map((step) => [step.id, step])),
+        request: plan.request,
         agentByStepId: Object.fromEntries(plan.steps.map((step) => [step.id, step.agent ?? "unknown"])),
-        resourcesByStepId: args.resourcesByStepId,
-        timeoutByStepId: Object.fromEntries(plan.steps.flatMap((step) => (step.timeout === undefined ? [] : [[step.id, step.timeout]]))),
-        budget: args.budget,
         runSession: args.runSession,
         synthesisEnabled: args.synthesisEnabled,
     };
@@ -349,7 +328,6 @@ export function buildAdHocPlan(request, route, createdAt = new Date().toISOStrin
                 packages: [...route.packages],
                 depends_on: [],
                 status: "pending",
-                resources: route.resources,
                 agent: route.agentId,
                 capability: route.capability,
                 maxSteps: meta?.defaultMaxSteps ?? DEFAULT_SANDBOX_MAX_STEPS,
@@ -394,7 +372,6 @@ async function persistedAdHocPlan(deps, args) {
         provider: deps.utilityProvider,
         model: deps.utilityModel,
         pool: deps.pool,
-        resourcePolicy: deps.resourcePolicy,
         logger: deps.logger,
         resolvePackages,
         usageRecorder: deps.usageRecorder,
@@ -426,9 +403,6 @@ async function launchReservedRun(deps, args) {
     const { session, planId, plan } = args;
     const analysisId = session.scope.analysisId;
     const threadId = session.scope.threadId ?? null;
-    const resources = stepResources(planId, plan);
-    if (resources.isErr())
-        return err(resources.error);
     // Reference data first: it is a read, so it costs nothing to learn before the farm link
     // writes. Both passes come before the run reserves anything, thus a miss of either leaves no
     // run row and no revoked authorization behind.
@@ -466,9 +440,7 @@ async function launchReservedRun(deps, args) {
         analysisId,
         threadId,
         runSession,
-        budget: deps.resourcePolicy?.budget,
         synthesisEnabled: args.mode === "plan",
-        resourcesByStepId: resources.value,
     });
     try {
         await deps.runLauncher.launch(deps.executeAnalysisWorkflow, { workflowId: runId }, wfInput);
@@ -649,7 +621,7 @@ export function createExecuteAnalysisTool(deps) {
         description: "Launch analysis computation asynchronously. Use mode=plan with the planId only after the user approved that stored plan. " +
             "Use mode=adhoc with the user's exact targeted computational request when they explicitly asked to run/compute/test/compare it; " +
             "that explicit request is consent and needs no synthetic-plan approval. If computation is merely your suggestion, ask first. " +
-            "You never choose the sandbox specialist: ad hoc routing does that automatically. Returns runId with status=in_progress; inspect results on a later turn. " +
+            "Returns runId with status=in_progress; inspect results on a later turn. " +
             "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,

package/dist/tools/report-authoring/authoring-tools.d.ts

@@ -16,8 +16,8 @@
  * The primitive admits a flat object input only. Thus a destination is four optional fields, and not a
  * nested union. A conflict between the flat fields refuses before the core runs.
  *
- * Inside a durable step, a mutation stores its result for the thread and the step, in the transaction of
- * the document and under the lock of the row. A rerun of the step after the landing, before its
+ * Inside a durable step, a mutation stores its result for the thread, the step, and the call, in the
+ * transaction of the document and under the lock of the row. A rerun of the step after the landing, before its
  * checkpoint, gives the stored result. Thus a rerun of `add_block` does not refuse its own block id, and a
  * rerun of `remove_block` does not refuse its own removed target.
  */

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

@@ -16,8 +16,8 @@
  * The primitive admits a flat object input only. Thus a destination is four optional fields, and not a
  * nested union. A conflict between the flat fields refuses before the core runs.
  *
- * Inside a durable step, a mutation stores its result for the thread and the step, in the transaction of
- * the document and under the lock of the row. A rerun of the step after the landing, before its
+ * Inside a durable step, a mutation stores its result for the thread, the step, and the call, in the
+ * transaction of the document and under the lock of the row. A rerun of the step after the landing, before its
  * checkpoint, gives the stored result. Thus a rerun of `add_block` does not refuse its own block id, and a
  * rerun of `remove_block` does not refuse its own removed target.
  */
@@ -133,6 +133,23 @@ const LandedResultSchema = z.object({
         })),
     })),
 });
+/** A refusal as a script reads it: the closed reason and the prose detail. */
+const RefusalOutputSchema = z.object({ reason: z.string(), detail: z.string() });
+const OutlineEntryOutputSchema = z.object({ id: z.string(), kind: z.string(), depth: z.number(), label: z.string() });
+/** The result of an edit, as `run_script` shows it to a script. A refused edit lands nothing. */
+const MutationOutputSchema = z.union([
+    z.object({
+        applied: z.literal(true),
+        changed: z.array(z.object({ parentId: z.string().optional(), children: z.array(OutlineEntryOutputSchema) })),
+    }),
+    z.object({ applied: z.literal(false), refusal: RefusalOutputSchema }),
+]);
+const OutlineOutputSchema = z.union([z.object({ outline: z.array(OutlineEntryOutputSchema) }), z.object({ refused: RefusalOutputSchema })]);
+const ReadBlockOutputSchema = z.union([
+    z.object({ found: z.literal(true), block: z.record(z.string(), z.unknown()) }),
+    z.object({ found: z.literal(false) }),
+    z.object({ refused: RefusalOutputSchema }),
+]);
 /**
  * Resolve the report thread of a call, and load its state through the gateway.
  *
@@ -439,7 +456,9 @@ export function createReportAuthoringTools(gateway, deps = {}) {
      * the landing of its own earlier run.
      */
     const openMutation = async (ctx) => {
-        const callKey = stepKey();
+        // The calls of one script share the step of `run_script`, thus the key names the call inside its step.
+        const step = stepKey();
+        const callKey = step === undefined ? undefined : `${step}:${ctx.invocationId}`;
         const opened = await openReportThread(gateway, ctx.session.scope, callKey);
         if (opened.isErr())
             return { done: refuse(opened.error) };
@@ -504,6 +523,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "The root admits a section only, and an atom needs a section as its parent. " +
             "A reference names the path of a pinned artifact, and the session stamps the hash from the pinned evidence.",
         inputSchema: addBlockInput,
+        outputSchema: MutationOutputSchema,
         describeCall: (input) => {
             const block = decodeBlockPayload(input.block);
             const kind = readKind(block);
@@ -534,10 +554,11 @@ export function createReportAuthoringTools(gateway, deps = {}) {
     });
     const change_block = defineTool({
         id: "change_block",
-        description: "Change one block by its id. Give a `title` to retitle a section, or a `block` to replace an atom, and never both. " +
+        description: "Change one block by its id: a `title` retitles a section, or a `block` replaces an atom, and never both. " +
             "The change keeps the id of the target, thus the `id` of the payload does not matter. A kind change is permitted. " +
             "A reference names the path of a pinned artifact, and the session stamps the hash from the pinned evidence.",
         inputSchema: changeBlockInput,
+        outputSchema: MutationOutputSchema,
         describeCall: (input) => `change ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -560,6 +581,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
         id: "remove_block",
         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,
         describeCall: (input) => `remove ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -579,6 +601,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
         description: "Move one block by its id to a new destination. Name the destination with `parentId` and one of `place`, `before`, or `after`. " +
             "A section cannot move into its own subtree.",
         inputSchema: moveBlockInput,
+        outputSchema: MutationOutputSchema,
         describeCall: (input) => `move ${input.targetId}`,
         execute: async (input, ctx) => {
             const opening = await openMutation(ctx);
@@ -596,9 +619,9 @@ export function createReportAuthoringTools(gateway, deps = {}) {
     });
     const set_title = defineTool({
         id: "set_title",
-        description: "Set the title of the report document. A draft starts with no title, and a document needs one. " +
-            "The title names the whole report, and it is not the title of a section.",
+        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,
         describeCall: (input) => `title the report ${input.title}`,
         // The title sits on the document, thus no container changes its child order.
         execute: async (input, ctx) => {
@@ -624,6 +647,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "A label that ends with the character … is clipped. Use the outline as the primary view of the draft, " +
             "and read one block when the label is not enough.",
         inputSchema: readOutlineInput,
+        outputSchema: OutlineOutputSchema,
         // The input carries no field, thus a hook can only restate the name of the tool.
         describeCall: "none",
         execute: async (_input, ctx) => {
@@ -640,6 +664,7 @@ export function createReportAuthoringTools(gateway, deps = {}) {
             "because the session owns the hash. A section gives its title and the id of each child, " +
             "because the outline already names every block under it. Use it when the outline label is not enough.",
         inputSchema: readBlockInput,
+        outputSchema: ReadBlockOutputSchema,
         describeCall: (input) => `read ${input.targetId}`,
         execute: async (input, ctx) => {
             const opened = await openThread(ctx);

package/dist/tools/report-session/index.d.ts

@@ -9,5 +9,4 @@ export { createPreviewReportTool, type PreviewReportInput, type PreviewReportRes
 export { createExaminePageTool, type CaptureCoverage, type CapturePage, type ExaminedTile, type ExaminePageInput, type ExaminePageResult, type ExaminePageToolDeps, type FailedRequest, type PageCapture, type ResolvePageUrl, } from "./examine-page.js";
 export { describeSessionPageMintFailure, UnavailableSessionPagePublisher, type MakeSessionPagePublisher, type SessionPageGrant, type SessionPageMintFailure, type SessionPagePublisher, } from "./session-page-publisher.js";
 export { createRecordVersionTool, type RecordVersionInput, type RecordVersionResult, type RecordVersionToolDeps } from "./record-version.js";
-export { createDeriveTableTool, type DeriveTableInput, type DeriveTableResult, type DeriveTableToolDeps } from "./derive-table.js";
 export { createListPinnedArtifactsTool, type ListPinnedArtifactsInput, type ListPinnedArtifactsResult, type ListPinnedArtifactsToolDeps, type PinnedArtifact, type PinnedCitation, } from "./list-artifacts.js";

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

@@ -9,5 +9,4 @@ export { createPreviewReportTool, } from "./preview-report.js";
 export { createExaminePageTool, } from "./examine-page.js";
 export { describeSessionPageMintFailure, UnavailableSessionPagePublisher, } from "./session-page-publisher.js";
 export { createRecordVersionTool } from "./record-version.js";
-export { createDeriveTableTool } from "./derive-table.js";
 export { createListPinnedArtifactsTool, } from "./list-artifacts.js";

package/dist/tools/report-session/script-tools.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The script tools of a report session: `read_table` over the pinned evidence, and `write_derived`, which pins a
+ * derived table to the session.
+ *
+ * A script reshapes the evidence into the table that a block binds: a join, a pivot, or an aggregate. The script
+ * runs in the VM of `run_script`, thus a derivation starts no container. A table over 16 MiB does not derive.
+ *
+ * `read_table` reads only a member of the served snapshot, and it refuses bytes whose hash is not the pinned hash.
+ * `write_derived` keeps the rules of a session derivation: the output lands under the derived directory of the session,
+ * each declared input must be a member, a name that the session holds is refused, and the record chains the
+ * table to its inputs and to the code of the script. A rerun of a call whose record landed gives that record
+ * back, and it emits the derivation again.
+ */
+import type { Logger } from "../../lib/logger.js";
+import { type ProvenanceSeam } from "../../provenance/seam.js";
+import type { ReportSessionStateStore } from "../../state/report-session-state.js";
+import type { WorkspaceFilesystem } from "../../workspace/filesystem.js";
+import { type ResolveWorkspaceRoot } from "../../workspace/paths.js";
+import { type Tool } from "../define-tool.js";
+import { type ReportSessionStateGateway } from "../report-authoring/authoring-tools.js";
+import { type SyncSessionFile } from "../../workspace/session-files.js";
+export type ReportScriptToolsDeps = {
+    readonly gateway: ReportSessionStateGateway;
+    readonly workspaceFs: WorkspaceFilesystem;
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    readonly derivations: Pick<ReportSessionStateStore, "appendDerivation">;
+    readonly provenance?: ProvenanceSeam;
+    /** The host copy of each derived table, owned by the thread of the session. */
+    readonly syncSessionFile?: SyncSessionFile;
+    readonly logger?: Logger;
+};
+/** The script tools of a report session. */
+export declare function createReportScriptTools(deps: ReportScriptToolsDeps): Tool[];