@inflexa-ai/harness 0.45.1 → 0.46.2

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

@@ -13,80 +13,55 @@
  * model three times, as a procedure step, as a claim view, and as a skeleton
  * step.
  */
+import type { z } from "zod";
 import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
+import { type Tool, type WithToolCallRecord } from "../define-tool.js";
 import type { KnowledgeClient, KnowledgeRejected, KnowledgeSnapshotMismatch, KnowledgeUnavailable, RecommendResponse } from "./client.js";
 import type { SnapshotPin } from "./pin.js";
 import { type EnvironmentPaths, type RecommendWithEnvironment } from "./environment.js";
+import { SituationFieldsSchema } from "./situation.js";
 import { type SkeletonStep } from "./skeleton.js";
-export interface KnowledgeRecommendDeps extends Omit<EnvironmentPaths, "farmLockFile"> {
+export type KnowledgeRecommendDeps = Omit<EnvironmentPaths, "farmLockFile"> & {
     readonly client: KnowledgeClient;
     /** Host path of the farm `inflexa.lock`, or its resolver for each analysis. Absent, the packages read as unknown. */
     readonly farmLockFile?: EnvironmentStorePaths["farmLockFile"];
     /**
-     * Receives each answer the planner sees. The planner keeps the skeleton of
-     * the invocation, thus `submit_plan` can restore a grounding field that the
+     * Receives each answer the planner saw, after the round of its call, on the
+     * first run and on each replay alike. The planner keeps the skeleton of the
+     * invocation, thus `submit_plan` can restore a grounding field that the
      * model dropped when it copied a skeleton step.
      */
     readonly onAnswer?: (answer: KnowledgeRecommendAnswer) => void;
     /**
-     * The release of the plan. The first answer sets it, and each later call
-     * of this tool and of `knowledge_check` sends it, thus a service that moved
-     * to another release between two calls refuses instead of mixing releases.
+     * The release of the plan. The first answer sets it after the round of its
+     * call, and each later call of this tool and of `knowledge_check` sends it,
+     * thus a service that moved to another release between two calls refuses
+     * instead of mixing releases.
      */
     readonly pin?: SnapshotPin;
-}
+};
 /**
  * The model-facing answer of the tool: the skeleton and the claims, with the
  * envelope of the service and the environment source. Never the procedure.
  */
-export interface KnowledgeRecommendAnswer {
+export type KnowledgeRecommendAnswer = {
     readonly match: RecommendResponse["match"];
     readonly snapshot: RecommendResponse["snapshot"];
     /** The situation as the service normalized it. */
     readonly situation?: Readonly<Record<string, unknown>>;
     readonly flags: RecommendResponse["flags"];
     /** The step types a flag removed. Absent when none. */
-    readonly dropped?: readonly string[];
+    dropped?: readonly string[];
     readonly uncovered: readonly string[];
     /** The step types whose method has no eligible template: covered by the knowledge, not by a vetted script. Absent when none. */
-    readonly unrealized?: readonly string[];
+    unrealized?: readonly string[];
     readonly environment_source?: RecommendWithEnvironment["environment_source"];
     readonly plan_skeleton: readonly SkeletonStep[];
     readonly claims: RecommendResponse["claims"];
-    readonly nearest?: RecommendResponse["nearest"];
-    readonly reason?: string;
-}
-export type KnowledgeRecommendOutput = KnowledgeRecommendAnswer | KnowledgeUnavailable | KnowledgeRejected | KnowledgeSnapshotMismatch;
+    nearest?: RecommendResponse["nearest"];
+    reason?: string;
+};
+export type KnowledgeRecommendOutput = WithToolCallRecord<KnowledgeRecommendAnswer, KnowledgeRecommendAnswer> | KnowledgeUnavailable | KnowledgeRejected | KnowledgeSnapshotMismatch;
 /** The one representation: the envelope, the skeleton, and the claims. The procedure stays host-side. */
 export declare function toPlannerAnswer(joined: RecommendWithEnvironment): KnowledgeRecommendAnswer;
-export declare function createKnowledgeRecommendTool(deps: KnowledgeRecommendDeps): import("../define-tool.js").Tool<{
-    question: "enrichment" | "differential_expression" | "qc" | "full_plan" | "tf_activity" | "deconvolution" | "coexpression" | "clustering" | "survival" | "signature_scoring";
-    modality: "bulk_rna_seq";
-    data_state: "fastq" | "counts" | "tpm_or_fpkm" | "log_normalized";
-    organism: "other" | "human" | "mouse";
-    n_groups: number;
-    n_per_group_min: number;
-    n_per_group_max: number;
-    paired: boolean;
-    batch: "none" | "known_balanced" | "known_confounded" | "known_unbalanced" | "suspected";
-    count_source?: "unknown" | "salmon" | "kallisto" | "star_featurecounts" | "rsem" | undefined;
-    import_state?: "unknown" | "quantifications" | "estimated_counts_with_lengths" | "corrected_counts" | "integer_counts" | undefined;
-    n_samples?: number | undefined;
-    n_events?: number | undefined;
-    blocking_factor?: "other" | "individual" | "cell_line" | "litter" | "site" | "pair" | null | undefined;
-    block_structure?: "crossed" | "nested" | undefined;
-    covariates?: ("other" | "technical" | "sex" | "age" | "clinical")[] | undefined;
-    n_timepoints?: number | null | undefined;
-    continuous_predictor?: "other" | "score" | "time" | "age" | "dose" | null | undefined;
-    technical_replicates?: boolean | undefined;
-    sample_exclusions?: boolean | undefined;
-    feature_level?: "gene" | "exon" | "transcript" | undefined;
-    library_type?: "unknown" | "total" | "polyA" | "three_prime" | undefined;
-    strandedness?: "unknown" | "verified" | "declared_unverified" | undefined;
-    interaction?: boolean | undefined;
-    classifier?: boolean | undefined;
-    extra_analyses?: ("tf_activity" | "deconvolution" | "coexpression" | "clustering" | "survival" | "signature_scoring" | "variance_partition" | "pathway_activity" | "transcript_level" | "annotation")[] | undefined;
-    preferred_language?: "R" | "python" | undefined;
-    enrichment_input?: "ranked_list" | "gene_list" | "sample_scores" | undefined;
-    quality_flags?: ("low_depth_sample" | "outlier_sample" | "sample_identity_doubt" | "high_duplication" | "degraded_rna")[] | undefined;
-}, KnowledgeRecommendOutput>;
+export declare function createKnowledgeRecommendTool(deps: KnowledgeRecommendDeps): Tool<z.infer<typeof SituationFieldsSchema>, KnowledgeRecommendOutput>;

package/dist/tools/knowledge/recommend.js

@@ -14,34 +14,37 @@
  * step.
  */
 import { ok } from "neverthrow";
-import { defineTool } from "../define-tool.js";
+import { parseUnknownRecord } from "../../lib/unknown-containers.js";
+import { defineTool, withToolCallRecord } from "../define-tool.js";
 import { joinEnvironment } from "./environment.js";
 import { SITUATION_EXAMPLE, SituationFieldsSchema, toPreferences, toSituation } from "./situation.js";
 import { buildPlanSkeleton } from "./skeleton.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function stringList(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined;
+    return Array.isArray(value) ? value.flatMap((item) => (typeof item === "string" ? [item] : [])) : undefined;
 }
 /** The one representation: the envelope, the skeleton, and the claims. The procedure stays host-side. */
 export function toPlannerAnswer(joined) {
-    const dropped = stringList(joined.dropped);
-    const unrealized = stringList(joined.unrealized);
-    return {
+    const answer = {
         match: joined.match,
         snapshot: joined.snapshot,
-        ...(isRecord(joined.situation) ? { situation: joined.situation } : {}),
+        situation: parseUnknownRecord(joined.situation),
         flags: joined.flags,
-        ...(dropped ? { dropped } : {}),
         uncovered: joined.uncovered,
-        ...(unrealized && unrealized.length > 0 ? { unrealized } : {}),
-        ...(joined.environment_source ? { environment_source: joined.environment_source } : {}),
+        environment_source: joined.environment_source,
         plan_skeleton: buildPlanSkeleton(joined),
         claims: joined.claims,
-        ...(joined.nearest ? { nearest: joined.nearest } : {}),
-        ...(joined.reason !== undefined ? { reason: joined.reason } : {}),
     };
+    const dropped = stringList(joined.dropped);
+    const unrealized = stringList(joined.unrealized);
+    if (dropped)
+        answer.dropped = dropped;
+    if (unrealized && unrealized.length > 0)
+        answer.unrealized = unrealized;
+    if (joined.nearest)
+        answer.nearest = joined.nearest;
+    if (joined.reason !== undefined)
+        answer.reason = joined.reason;
+    return answer;
 }
 export function createKnowledgeRecommendTool(deps) {
     return defineTool({
@@ -86,13 +89,18 @@ export function createKnowledgeRecommendTool(deps) {
             deps.pin?.set(answer.snapshot.digest);
             const farmLockFile = typeof deps.farmLockFile === "function" ? deps.farmLockFile(ctx.session.scope.analysisId) : deps.farmLockFile;
             const joined = await joinEnvironment(answer, {
-                ...(farmLockFile ? { farmLockFile } : {}),
-                ...(deps.imagePackagesFile ? { imagePackagesFile: deps.imagePackagesFile } : {}),
-                ...(deps.refStorePath ? { refStorePath: deps.refStorePath } : {}),
+                farmLockFile,
+                imagePackagesFile: deps.imagePackagesFile,
+                refStorePath: deps.refStorePath,
             });
             const planner = toPlannerAnswer(joined);
-            deps.onAnswer?.(planner);
-            return ok(planner);
+            // The answer rides as the call record too. The pin and the memory of the planner
+            // fold it after the round, thus a replay that returns the recorded result sets both.
+            return ok(withToolCallRecord(planner, planner));
+        },
+        foldCallRecord: (answer) => {
+            deps.pin?.set(answer.snapshot.digest);
+            deps.onAnswer?.(answer);
         },
     });
 }

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

@@ -8,42 +8,42 @@ import { z } from "zod";
 import type { KnowledgeSituation, KnowledgePreferences } from "./client.js";
 export declare const SituationFieldsSchema: z.ZodObject<{
     question: z.ZodEnum<{
-        enrichment: "enrichment";
+        clustering: "clustering";
+        coexpression: "coexpression";
+        deconvolution: "deconvolution";
         differential_expression: "differential_expression";
-        qc: "qc";
+        enrichment: "enrichment";
         full_plan: "full_plan";
-        tf_activity: "tf_activity";
-        deconvolution: "deconvolution";
-        coexpression: "coexpression";
-        clustering: "clustering";
-        survival: "survival";
+        qc: "qc";
         signature_scoring: "signature_scoring";
+        survival: "survival";
+        tf_activity: "tf_activity";
     }>;
     modality: z.ZodLiteral<"bulk_rna_seq">;
     data_state: z.ZodEnum<{
-        fastq: "fastq";
         counts: "counts";
-        tpm_or_fpkm: "tpm_or_fpkm";
+        fastq: "fastq";
         log_normalized: "log_normalized";
+        tpm_or_fpkm: "tpm_or_fpkm";
     }>;
     count_source: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
-        salmon: "salmon";
         kallisto: "kallisto";
-        star_featurecounts: "star_featurecounts";
         rsem: "rsem";
+        salmon: "salmon";
+        star_featurecounts: "star_featurecounts";
+        unknown: "unknown";
     }>>;
     import_state: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
-        quantifications: "quantifications";
-        estimated_counts_with_lengths: "estimated_counts_with_lengths";
         corrected_counts: "corrected_counts";
+        estimated_counts_with_lengths: "estimated_counts_with_lengths";
         integer_counts: "integer_counts";
+        quantifications: "quantifications";
+        unknown: "unknown";
     }>>;
     organism: z.ZodEnum<{
-        other: "other";
         human: "human";
         mouse: "mouse";
+        other: "other";
     }>;
     n_groups: z.ZodNumber;
     n_per_group_min: z.ZodNumber;
@@ -52,90 +52,90 @@ export declare const SituationFieldsSchema: z.ZodObject<{
     n_events: z.ZodOptional<z.ZodNumber>;
     paired: z.ZodBoolean;
     blocking_factor: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        other: "other";
-        individual: "individual";
         cell_line: "cell_line";
+        individual: "individual";
         litter: "litter";
-        site: "site";
+        other: "other";
         pair: "pair";
+        site: "site";
     }>>>;
     block_structure: z.ZodOptional<z.ZodEnum<{
         crossed: "crossed";
         nested: "nested";
     }>>;
     batch: z.ZodEnum<{
-        none: "none";
         known_balanced: "known_balanced";
         known_confounded: "known_confounded";
         known_unbalanced: "known_unbalanced";
+        none: "none";
         suspected: "suspected";
     }>;
     covariates: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        other: "other";
-        technical: "technical";
-        sex: "sex";
         age: "age";
         clinical: "clinical";
+        other: "other";
+        sex: "sex";
+        technical: "technical";
     }>>>;
     n_timepoints: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     continuous_predictor: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        age: "age";
+        dose: "dose";
         other: "other";
         score: "score";
         time: "time";
-        age: "age";
-        dose: "dose";
     }>>>;
     technical_replicates: z.ZodOptional<z.ZodBoolean>;
     sample_exclusions: z.ZodOptional<z.ZodBoolean>;
     feature_level: z.ZodOptional<z.ZodEnum<{
-        gene: "gene";
         exon: "exon";
+        gene: "gene";
         transcript: "transcript";
     }>>;
     library_type: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
-        total: "total";
         polyA: "polyA";
         three_prime: "three_prime";
+        total: "total";
+        unknown: "unknown";
     }>>;
     strandedness: z.ZodOptional<z.ZodEnum<{
+        declared_unverified: "declared_unverified";
         unknown: "unknown";
         verified: "verified";
-        declared_unverified: "declared_unverified";
     }>>;
     interaction: z.ZodOptional<z.ZodBoolean>;
     classifier: z.ZodOptional<z.ZodBoolean>;
     extra_analyses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        tf_activity: "tf_activity";
-        deconvolution: "deconvolution";
-        coexpression: "coexpression";
+        annotation: "annotation";
         clustering: "clustering";
-        survival: "survival";
-        signature_scoring: "signature_scoring";
-        variance_partition: "variance_partition";
+        coexpression: "coexpression";
+        deconvolution: "deconvolution";
         pathway_activity: "pathway_activity";
+        signature_scoring: "signature_scoring";
+        survival: "survival";
+        tf_activity: "tf_activity";
         transcript_level: "transcript_level";
-        annotation: "annotation";
+        variance_partition: "variance_partition";
     }>>>;
     preferred_language: z.ZodOptional<z.ZodEnum<{
         R: "R";
         python: "python";
     }>>;
     enrichment_input: z.ZodOptional<z.ZodEnum<{
-        ranked_list: "ranked_list";
         gene_list: "gene_list";
+        ranked_list: "ranked_list";
         sample_scores: "sample_scores";
     }>>;
     quality_flags: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        degraded_rna: "degraded_rna";
+        high_duplication: "high_duplication";
         low_depth_sample: "low_depth_sample";
         outlier_sample: "outlier_sample";
         sample_identity_doubt: "sample_identity_doubt";
-        high_duplication: "high_duplication";
-        degraded_rna: "degraded_rna";
     }>>>;
 }, z.core.$strip>;
 export type SituationFields = z.infer<typeof SituationFieldsSchema>;
-/** The situation as the client sends it: the fields as given, with an absent optional field omitted. */
+/** The situation as the client sends it: the fields as given, with the caller preference held out of the situation fields. */
 export declare function toSituation(fields: SituationFields): KnowledgeSituation;
 /** The preferences of the caller, beside the situation: the language of the template. */
 export declare function toPreferences(fields: SituationFields): KnowledgePreferences | undefined;

package/dist/tools/knowledge/situation.js

@@ -143,16 +143,9 @@ export const SituationFieldsSchema = z.object({
         .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)."),
 });
-/** The situation as the client sends it: the fields as given, with an absent optional field omitted. */
+/** 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) {
-    const situation = {};
-    for (const [key, value] of Object.entries(fields)) {
-        if (key === "preferred_language")
-            continue;
-        if (value !== undefined)
-            situation[key] = value;
-    }
-    // The schema above validated every field, thus the record has the shape of the client type.
+    const { preferred_language: _omitted, ...situation } = fields;
     return situation;
 }
 /** The preferences of the caller, beside the situation: the language of the template. */

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

@@ -30,13 +30,13 @@
  */
 import type { GroundingSetting } from "../../schemas/workflow-state.js";
 import type { RecommendWithEnvironment, StepEnvironment } from "./environment.js";
-export interface SkeletonAlternative {
+export type SkeletonAlternative = {
     readonly method: string;
     readonly label: string;
     readonly when: string;
     readonly rules: readonly string[];
-}
-export interface SkeletonStep {
+};
+export type SkeletonStep = {
     readonly id: string;
     readonly name: string;
     readonly track: string;
@@ -65,5 +65,5 @@ export interface SkeletonStep {
         readonly settings: readonly GroundingSetting[];
         readonly reason: string;
     };
-}
+};
 export declare function buildPlanSkeleton(answer: RecommendWithEnvironment): SkeletonStep[];

package/dist/tools/knowledge/skeleton.js

@@ -28,6 +28,7 @@
  * setting of the grounding, never a constraint of the step: the value is the
  * vetted default, and the agent can state another value with its reason.
  */
+import { textOf } from "../../lib/unknown-text.js";
 const GROUPS = [
     { id: "T0S1", track: "T1", step_type: "data_preparation", agent: "bulk-transcriptomics-agent", steps: ["cohort_assembly"], name: "Cohort assembly" },
     { id: "T1S1", track: "T1", step_type: "qc", agent: "bulk-transcriptomics-agent", steps: ["qc_sample_structure"], name: "Sample structure QC" },
@@ -86,7 +87,7 @@ function settingValue(value) {
         return value;
     if (Array.isArray(value))
         return value.map(String);
-    return String(value);
+    return textOf(value);
 }
 /** The settings of the steps of a group: one entry per parameter, with the step it belongs to. */
 function stepSettings(steps) {
@@ -94,19 +95,19 @@ function stepSettings(steps) {
         step: step.step,
         name: parameter.name,
         value: settingValue(parameter.value),
-        ...(parameter.default_source ? { source: parameter.default_source } : {}),
+        source: parameter.default_source,
     })));
 }
 /** The forbidden method ids of a step. The client schema reads the field through the loose object. */
 function forbidsOf(step) {
     const forbids = step.forbids;
-    return Array.isArray(forbids) ? forbids.filter((method) => typeof method === "string") : [];
+    return Array.isArray(forbids) ? forbids.flatMap((method) => (typeof method === "string" ? [method] : [])) : [];
 }
 /** `a and b`, or `a, b and c` for a longer list. */
 function joinWithAnd(items) {
     if (items.length <= 1)
         return items.join("");
-    return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+    return `${items.slice(0, -1).join(", ")} and ${String(items[items.length - 1])}`;
 }
 /**
  * The caveats a step carries beside its warn flags. A parameter conflict, a
@@ -155,9 +156,7 @@ export function buildPlanSkeleton(answer) {
         const flags = steps.flatMap((step) => step.flags ?? []);
         const hardFlag = flags.find((flag) => flag.severity === "flag");
         const claims = [...new Set(steps.flatMap((step) => step.rules))];
-        const packages = [
-            ...new Set(steps.map((step) => step.package?.name).filter((name) => name !== undefined)),
-        ];
+        const packages = [...new Set(steps.map((step) => step.package?.name).flatMap((name) => (name !== undefined ? [name] : [])))];
         const caveats = [...flags.filter((flag) => flag.severity === "warn").map((flag) => flag.message), ...steps.flatMap(stepCaveats)];
         const method = central?.method;
         // A rule covers the group when a step of the group carries one. A method
@@ -180,21 +179,21 @@ export function buildPlanSkeleton(answer) {
             depends_on: dependsOn(group.id, keptIds),
             caveats: hardFlag ? [hardFlag.message, ...caveats] : caveats,
             alternatives,
-            ...(disputed ? { disputed: { rule: disputed.rule, sides: disputed.sides } } : {}),
+            disputed: disputed === undefined ? undefined : { rule: disputed.rule, sides: disputed.sides },
             forbids,
-            ...(central?.environment ? { environment: central.environment } : {}),
+            environment: central?.environment,
             grounding: {
                 status,
                 snapshot: answer.snapshot.digest,
                 claims,
-                ...(central?.template ? { template: central.template } : {}),
+                template: central?.template,
                 settings: stepSettings(steps),
                 reason: hardFlag
                     ? `flagged by ${hardFlag.rule}`
                     : method
                         ? `${method.label} per ${claims[0] ?? "the procedure"}`
                         : covered
-                            ? `${group.name} per ${claims[0]}`
+                            ? `${group.name} per ${String(claims[0])}`
                             : "no rule covers this step",
             },
         };

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

@@ -25,8 +25,9 @@
  * one durable step, thus a replay returns the cached result and renders
  * nothing again.
  */
+import { z } from "zod";
 import type { EnvironmentStorePaths } from "../../config/environment-stores.js";
-import { type WithToolCallRecord } from "../define-tool.js";
+import { type Tool, type WithToolCallRecord } from "../define-tool.js";
 import type { WorkspaceMutator, WriteFileResult, WriteRecord } from "../workspace/mutator.js";
 import type { KnowledgeClient, KnowledgeRejected, KnowledgeSnapshotMismatch, KnowledgeUnavailable, TemplateParameter } from "./client.js";
 /** A slot value the plan binds: a scalar, or a list of strings. JSON-serialisable, as the durable step input needs. */
@@ -39,7 +40,7 @@ export type TemplateBindingValue = string | number | boolean | readonly string[]
  * the plan step: its id, its claims, the release the plan pinned, and the
  * local slots of the contract that the tool binds on the machine.
  */
-export interface TemplateBinding {
+export type TemplateBinding = {
     /** The template reference of the plan step, with its version, for example `tpl-deseq2-two-group@1.0.0`. */
     readonly template: string;
     readonly slots: Readonly<Record<string, TemplateBindingValue>>;
@@ -54,8 +55,8 @@ export interface TemplateBinding {
     readonly local?: readonly TemplateParameter[];
     /** The names of every adaptable slot of the served contract, thus the tool refuses an unknown name before anything leaves the machine. */
     readonly adaptable?: readonly string[];
-}
-export interface KnowledgeTemplateDeps {
+};
+export type KnowledgeTemplateDeps = {
     readonly client: KnowledgeClient;
     readonly mutator: WorkspaceMutator;
     /** Host path of the farm `inflexa.lock`, or its resolver for each analysis. Absent with no image record, the environment match reads as unknown. */
@@ -64,20 +65,20 @@ export interface KnowledgeTemplateDeps {
     readonly imagePackagesFile?: string;
     /** The plan settings bound to the template of the step. Absent, the model values ride alone. */
     readonly binding?: TemplateBinding;
-}
+};
 /** One bound slot as the decision record keeps it. */
-export interface BoundSlotRecord {
+export type BoundSlotRecord = {
     readonly slot: string;
     readonly value: TemplateBindingValue;
     readonly source: string;
-}
+};
 /** One change of a bound value that an `overrides` entry declared, as the decision record keeps it. */
-export interface SettingsOverrideRecord {
+export type SettingsOverrideRecord = {
     readonly slot: string;
     readonly plan_value: TemplateBindingValue;
     readonly new_value: unknown;
     readonly reason: string;
-}
+};
 export type KnowledgeTemplateOutput = {
     readonly status: "ok";
     readonly script_path: string;
@@ -125,13 +126,14 @@ export type KnowledgeTemplateOutput = {
 } | KnowledgeUnavailable | KnowledgeRejected | KnowledgeSnapshotMismatch;
 /** The result of a `knowledge_template` call: each landed write rides as the call record, for the fold. */
 type KnowledgeTemplateResult = KnowledgeTemplateOutput | WithToolCallRecord<KnowledgeTemplateOutput, readonly WriteRecord[]>;
-export declare function createKnowledgeTemplateTool(deps: KnowledgeTemplateDeps): import("../define-tool.js").Tool<{
-    template: string;
-    slots: Record<string, unknown>;
-    overrides?: {
-        slot: string;
-        reason: string;
-    }[] | undefined;
-    script_name?: string | undefined;
-}, KnowledgeTemplateResult>;
+declare const KnowledgeTemplateInputSchema: z.ZodObject<{
+    template: z.ZodString;
+    slots: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        slot: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+    script_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createKnowledgeTemplateTool(deps: KnowledgeTemplateDeps): Tool<z.infer<typeof KnowledgeTemplateInputSchema>, KnowledgeTemplateResult>;
 export {};