@inflexa-ai/harness 0.44.0 → 0.45.1

package/dist/sandbox/image-packages.js

@@ -1,9 +1,11 @@
 /**
  * `image-packages.json` — the self-description of the sandbox image.
  *
- * The image bakes two package tracks that the content-addressed store cannot
- * hold: the conda tools at `/opt/conda` and the Node packages at `/opt/node`.
- * The image writes one record of them at `/opt/inflexa/image-packages.json`,
+ * The image bakes the package tracks that the content-addressed store cannot
+ * hold: the conda tools at `/opt/conda`, the Node packages at `/opt/node`,
+ * and the R packages that ship with the R runtime (the base and the
+ * recommended packages, which no farm lock lists). The image writes one
+ * record of them at `/opt/inflexa/image-packages.json`,
  * and the catalog build copies that record verbatim into the root of the
  * package store it packed beside it. Thus every reader of a store learns the
  * image inventory from the store alone — with no container engine, no
@@ -63,10 +65,21 @@ export const ImageNodePackageSchema = z
     version: z.string(),
 })
     .passthrough();
+/** One R package that ships with the R runtime of the image: a base package or a recommended package. */
+export const ImageRBasePackageSchema = z
+    .object({
+    name: z.string(),
+    version: z.string(),
+    priority: z.enum(["base", "recommended"]),
+})
+    .passthrough();
 /**
  * `image-packages.json` at schema version 1. The keys `system_tools` and
  * `node` are the keys of the image manifest, thus one name means one track
- * across the build and the reader.
+ * across the build and the reader. `r_base` is the track of the R runtime
+ * itself: the packages R ships, which no manifest names and no farm lock
+ * lists. It is optional, because a record from before the field existed is
+ * still a valid record of its image.
  */
 export const ImagePackagesSchema = z
     .object({
@@ -75,6 +88,7 @@ export const ImagePackagesSchema = z
     runtimes: ImageRuntimesSchema,
     system_tools: z.array(ImageSystemToolSchema),
     node: z.array(ImageNodePackageSchema),
+    r_base: z.array(ImageRBasePackageSchema).optional(),
 })
     .passthrough();
 /**

package/dist/sandbox/sandbox-step-translate.d.ts

@@ -5,6 +5,7 @@
  * extraction/fold, and the chat-data-part narrowing a workflow body composes
  * into its emitters.
  */
+import type { ActivityEntryPart, StepActivityPart, StepPhase, SynthesisPhase, SynthesisProgressPart } from "../contracts/chat-parts.js";
 import type { ChatDataPart, EmitFn } from "../loop/types.js";
 import type { ToolDetailResolver } from "../tools/detail-resolver.js";
 /**
@@ -19,6 +20,28 @@ import type { ToolDetailResolver } from "../tools/detail-resolver.js";
  * producers construct it identically.
  */
 export declare function stepPartId(kind: string, runId: string, stepId: string): string;
+/**
+ * The two parts of one activity emission: the reconciling `data-step-activity` that holds the current activity,
+ * and the `data-activity-entry` that keeps the emission in the run stream. Both carry the same phase, activity,
+ * and time. `seq` is the position of the emission in the body of its workflow, so each entry has its own id, and a
+ * recovered body counts the same emissions again and gives the same ids. Every producer mints the two parts here.
+ */
+export declare function activityEmission(frame: {
+    readonly runId: string;
+    readonly stepId: string;
+}, seq: number, phase: StepPhase, activity: string, at: string): {
+    readonly activity: StepActivityPart;
+    readonly entry: ActivityEntryPart;
+};
+/**
+ * The two parts of one synthesis progress report: the reconciling `data-synthesis-progress` that holds the current
+ * phase, and the `data-activity-entry` that keeps the report in the run stream under the synthesis step. `seq` is the
+ * position of the report in the synthesis, so each entry has its own id. The `extra` fields stay on the progress part.
+ */
+export declare function synthesisEmission(runId: string, stepId: string, seq: number, phase: SynthesisPhase, activity: string, at: string, extra: Pick<SynthesisProgressPart, "delegationCount" | "reason" | "error">): {
+    readonly progress: SynthesisProgressPart;
+    readonly entry: ActivityEntryPart;
+};
 /**
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.

package/dist/sandbox/sandbox-step-translate.js

@@ -19,6 +19,30 @@
 export function stepPartId(kind, runId, stepId) {
     return `${kind}-${runId}-${stepId}`;
 }
+/**
+ * The two parts of one activity emission: the reconciling `data-step-activity` that holds the current activity,
+ * and the `data-activity-entry` that keeps the emission in the run stream. Both carry the same phase, activity,
+ * and time. `seq` is the position of the emission in the body of its workflow, so each entry has its own id, and a
+ * recovered body counts the same emissions again and gives the same ids. Every producer mints the two parts here.
+ */
+export function activityEmission(frame, seq, phase, activity, at) {
+    const { runId, stepId } = frame;
+    return {
+        activity: { type: "data-step-activity", id: stepPartId("step-activity", runId, stepId), runId, stepId, phase, activity, at },
+        entry: { type: "data-activity-entry", id: `${stepPartId("activity-entry", runId, stepId)}-${seq}`, runId, stepId, phase, activity, at },
+    };
+}
+/**
+ * The two parts of one synthesis progress report: the reconciling `data-synthesis-progress` that holds the current
+ * phase, and the `data-activity-entry` that keeps the report in the run stream under the synthesis step. `seq` is the
+ * position of the report in the synthesis, so each entry has its own id. The `extra` fields stay on the progress part.
+ */
+export function synthesisEmission(runId, stepId, seq, phase, activity, at, extra) {
+    return {
+        progress: { type: "data-synthesis-progress", id: `synthesis-progress-${runId}`, runId, phase, activity, at, ...extra },
+        entry: { type: "data-activity-entry", id: `${stepPartId("activity-entry", runId, stepId)}-${seq}`, runId, stepId, phase, activity, at },
+    };
+}
 /**
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.

package/dist/schemas/artifact-manifest.d.ts

@@ -30,5 +30,5 @@ export declare const ArtifactManifestEntrySchema: z.ZodObject<{
     hash: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ArtifactManifestEntry = z.infer<typeof ArtifactManifestEntrySchema>;
-/** Infer artifact type from a file path based on its parent subdirectory. */
+/** Infer artifact type from a file path. A folder segment at the start of the path or after a `/` gives its type. */
 export declare function inferArtifactType(filePath: string): ArtifactType;

package/dist/schemas/artifact-manifest.js

@@ -22,15 +22,17 @@ export const ArtifactManifestEntrySchema = z.object({
     /** SHA-256 content hash for integrity verification (e.g., sha256:abcdef...). */
     hash: z.string().optional(),
 });
-/** Infer artifact type from a file path based on its parent subdirectory. */
+const FOLDER_TYPES = [
+    ["figures", "figure"],
+    ["scripts", "script"],
+    ["logs", "log"],
+    ["notebooks", "notebook"],
+];
+/** Infer artifact type from a file path. A folder segment at the start of the path or after a `/` gives its type. */
 export function inferArtifactType(filePath) {
-    if (filePath.includes("/figures/"))
-        return "figure";
-    if (filePath.includes("/scripts/"))
-        return "script";
-    if (filePath.includes("/logs/"))
-        return "log";
-    if (filePath.includes("/notebooks/"))
-        return "notebook";
+    for (const [folder, type] of FOLDER_TYPES) {
+        if (filePath.startsWith(`${folder}/`) || filePath.includes(`/${folder}/`))
+            return type;
+    }
     return "output";
 }

package/dist/schemas/data-profile-schemas.d.ts

@@ -462,6 +462,8 @@ export declare const DimensionSchema: z.ZodObject<{
         other: "other";
         sex: "sex";
         subject: "subject";
+        environment: "environment";
+        batch: "batch";
         sample: "sample";
         "organism-species": "organism-species";
         "model-system": "model-system";
@@ -474,14 +476,12 @@ export declare const DimensionSchema: z.ZodObject<{
         "genetic-perturbation": "genetic-perturbation";
         "age-group": "age-group";
         "developmental-stage": "developmental-stage";
-        environment: "environment";
         "assay-modality": "assay-modality";
         "assay-target": "assay-target";
         "variant-origin": "variant-origin";
         "sample-pairing": "sample-pairing";
         "processing-level": "processing-level";
         "assay-version": "assay-version";
-        batch: "batch";
         replicate: "replicate";
         "tool-variant": "tool-variant";
         "library-prep": "library-prep";
@@ -541,20 +541,20 @@ export type ProfileDimension = z.infer<typeof DimensionSchema>;
 export declare const ProbeReportSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     probe: z.ZodEnum<{
         subject: "subject";
+        batch: "batch";
         sample: "sample";
         "cohort-arm": "cohort-arm";
         timepoint: "timepoint";
-        batch: "batch";
     }>;
     outcome: z.ZodLiteral<"found">;
     dimension: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     probe: z.ZodEnum<{
         subject: "subject";
+        batch: "batch";
         sample: "sample";
         "cohort-arm": "cohort-arm";
         timepoint: "timepoint";
-        batch: "batch";
     }>;
     outcome: z.ZodLiteral<"not-found">;
     searched: z.ZodArray<z.ZodString>;
@@ -562,10 +562,10 @@ export declare const ProbeReportSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>, z.ZodObject<{
     probe: z.ZodEnum<{
         subject: "subject";
+        batch: "batch";
         sample: "sample";
         "cohort-arm": "cohort-arm";
         timepoint: "timepoint";
-        batch: "batch";
     }>;
     outcome: z.ZodLiteral<"found-but-constant">;
     value: z.ZodString;
@@ -573,10 +573,10 @@ export declare const ProbeReportSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>, z.ZodObject<{
     probe: z.ZodEnum<{
         subject: "subject";
+        batch: "batch";
         sample: "sample";
         "cohort-arm": "cohort-arm";
         timepoint: "timepoint";
-        batch: "batch";
     }>;
     outcome: z.ZodLiteral<"attested">;
     citation: z.ZodString;
@@ -873,6 +873,8 @@ export declare const ProfileSubmissionSchema: z.ZodObject<{
             other: "other";
             sex: "sex";
             subject: "subject";
+            environment: "environment";
+            batch: "batch";
             sample: "sample";
             "organism-species": "organism-species";
             "model-system": "model-system";
@@ -885,14 +887,12 @@ export declare const ProfileSubmissionSchema: z.ZodObject<{
             "genetic-perturbation": "genetic-perturbation";
             "age-group": "age-group";
             "developmental-stage": "developmental-stage";
-            environment: "environment";
             "assay-modality": "assay-modality";
             "assay-target": "assay-target";
             "variant-origin": "variant-origin";
             "sample-pairing": "sample-pairing";
             "processing-level": "processing-level";
             "assay-version": "assay-version";
-            batch: "batch";
             replicate: "replicate";
             "tool-variant": "tool-variant";
             "library-prep": "library-prep";
@@ -946,20 +946,20 @@ export declare const ProfileSubmissionSchema: z.ZodObject<{
     probes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         probe: z.ZodEnum<{
             subject: "subject";
+            batch: "batch";
             sample: "sample";
             "cohort-arm": "cohort-arm";
             timepoint: "timepoint";
-            batch: "batch";
         }>;
         outcome: z.ZodLiteral<"found">;
         dimension: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         probe: z.ZodEnum<{
             subject: "subject";
+            batch: "batch";
             sample: "sample";
             "cohort-arm": "cohort-arm";
             timepoint: "timepoint";
-            batch: "batch";
         }>;
         outcome: z.ZodLiteral<"not-found">;
         searched: z.ZodArray<z.ZodString>;
@@ -967,10 +967,10 @@ export declare const ProfileSubmissionSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         probe: z.ZodEnum<{
             subject: "subject";
+            batch: "batch";
             sample: "sample";
             "cohort-arm": "cohort-arm";
             timepoint: "timepoint";
-            batch: "batch";
         }>;
         outcome: z.ZodLiteral<"found-but-constant">;
         value: z.ZodString;
@@ -978,10 +978,10 @@ export declare const ProfileSubmissionSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         probe: z.ZodEnum<{
             subject: "subject";
+            batch: "batch";
             sample: "sample";
             "cohort-arm": "cohort-arm";
             timepoint: "timepoint";
-            batch: "batch";
         }>;
         outcome: z.ZodLiteral<"attested">;
         citation: z.ZodString;

package/dist/schemas/plan-schemas.d.ts

@@ -7,17 +7,12 @@ import type { AnalysisPlan } from "./workflow-state.js";
 /** Step schema for planner output — omits fields populated at execution time
  *  and the hardcoded sandbox turn budget. */
 export declare const PlanStepSchema: z.ZodObject<{
-    name: z.ZodString;
     context: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    track: z.ZodString;
-    step_type: z.ZodString;
-    question: z.ZodString;
-    acceptance_criteria: z.ZodArray<z.ZodString>;
     caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    question: z.ZodString;
     depends_on: z.ZodArray<z.ZodString>;
     resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
         cpu: z.ZodNumber;
@@ -26,6 +21,29 @@ export declare const PlanStepSchema: z.ZodObject<{
             count: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    grounding: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            grounded: "grounded";
+            ungrounded: "ungrounded";
+            flagged: "flagged";
+        }>;
+        snapshot: z.ZodString;
+        claims: z.ZodArray<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            name: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    track: z.ZodString;
+    step_type: z.ZodString;
+    acceptance_criteria: z.ZodArray<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    capability: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
     agent: z.ZodEnum<{
         [x: string]: string;
     }>;
@@ -40,17 +58,12 @@ export declare const PlannerPlanSchema: z.ZodObject<{
     omicsSubtype: z.ZodOptional<z.ZodString>;
     title: z.ZodString;
     steps: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
         context: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
-        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        track: z.ZodString;
-        step_type: z.ZodString;
-        question: z.ZodString;
-        acceptance_criteria: z.ZodArray<z.ZodString>;
         caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        question: z.ZodString;
         depends_on: z.ZodArray<z.ZodString>;
         resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
             cpu: z.ZodNumber;
@@ -59,6 +72,29 @@ export declare const PlannerPlanSchema: z.ZodObject<{
                 count: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
+        grounding: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                grounded: "grounded";
+                ungrounded: "ungrounded";
+                flagged: "flagged";
+            }>;
+            snapshot: z.ZodString;
+            claims: z.ZodArray<z.ZodString>;
+            template: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                step: z.ZodString;
+                name: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                source: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        track: z.ZodString;
+        step_type: z.ZodString;
+        acceptance_criteria: z.ZodArray<z.ZodString>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        capability: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
         agent: z.ZodEnum<{
             [x: string]: string;
         }>;
@@ -82,17 +118,12 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
         omicsSubtype: z.ZodOptional<z.ZodString>;
         title: z.ZodString;
         steps: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
             context: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
-            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            track: z.ZodString;
-            step_type: z.ZodString;
-            question: z.ZodString;
-            acceptance_criteria: z.ZodArray<z.ZodString>;
             caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            question: z.ZodString;
             depends_on: z.ZodArray<z.ZodString>;
             resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
                 cpu: z.ZodNumber;
@@ -101,6 +132,29 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
                     count: z.ZodNumber;
                 }, z.core.$strip>>;
             }, z.core.$strip>>>;
+            grounding: z.ZodOptional<z.ZodObject<{
+                status: z.ZodEnum<{
+                    grounded: "grounded";
+                    ungrounded: "ungrounded";
+                    flagged: "flagged";
+                }>;
+                snapshot: z.ZodString;
+                claims: z.ZodArray<z.ZodString>;
+                template: z.ZodOptional<z.ZodString>;
+                settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    step: z.ZodString;
+                    name: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                    source: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
+            track: z.ZodString;
+            step_type: z.ZodString;
+            acceptance_criteria: z.ZodArray<z.ZodString>;
+            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            capability: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
             agent: z.ZodEnum<{
                 [x: string]: string;
             }>;

package/dist/schemas/plan-schemas.js

@@ -17,7 +17,7 @@ export const PlanStepSchema = AnalysisStepSchema.omit({
     error: true,
     maxSteps: true,
 })
-    .required({ agent: true, resources: true, packages: true })
+    .required({ agent: true, resources: true, packages: true, capability: true })
     .extend({
     agent: z.enum(plannableAgentIds).describe("Sandbox agent ID, routed by the step's primary data object. Must be one of the available agents."),
 });

package/dist/schemas/run-synthesis.d.ts

@@ -31,11 +31,11 @@ export declare const SynthesizedFindingSchema: z.ZodObject<{
         high: "high";
     }>;
     noveltyStatus: z.ZodEnum<{
-        expected: "expected";
         novel: "novel";
         confirmed: "confirmed";
         partially_confirmed: "partially_confirmed";
         contradicted: "contradicted";
+        expected: "expected";
     }>;
     literatureInterpretation: z.ZodString;
     references: z.ZodArray<z.ZodObject<{
@@ -97,11 +97,11 @@ export declare const RunSynthesisSchema: z.ZodObject<{
             high: "high";
         }>;
         noveltyStatus: z.ZodEnum<{
-            expected: "expected";
             novel: "novel";
             confirmed: "confirmed";
             partially_confirmed: "partially_confirmed";
             contradicted: "contradicted";
+            expected: "expected";
         }>;
         literatureInterpretation: z.ZodString;
         references: z.ZodArray<z.ZodObject<{

package/dist/schemas/workflow-state.d.ts

@@ -5,6 +5,47 @@
  * and the completion schemas that validate LLM structured output.
  */
 import { z } from "zod";
+/**
+ * One scientific setting of a grounded step: a parameter of the procedure
+ * that `knowledge_recommend` returned, with the procedure step it belongs to
+ * and the source of its value. The host binds the settings to the template
+ * of the step at dispatch, thus a template default never replaces a plan
+ * decision silently.
+ */
+export declare const GroundingSettingSchema: z.ZodObject<{
+    step: z.ZodString;
+    name: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GroundingSetting = z.infer<typeof GroundingSettingSchema>;
+/**
+ * The grounding of one method step: the claim identifiers and the snapshot
+ * digest that `knowledge_recommend` returned in this run, the template the
+ * step renders, the settings of the procedure, and a one-line reason.
+ * Optional on both step schemas, thus a stored plan and a plan made without
+ * the knowledge service load and validate as before. Phase 0 validates the
+ * shape only. An empty field is visible: the evaluation counts a method step
+ * without a value as ungrounded.
+ */
+export declare const GroundingSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        grounded: "grounded";
+        ungrounded: "ungrounded";
+        flagged: "flagged";
+    }>;
+    snapshot: z.ZodString;
+    claims: z.ZodArray<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        step: z.ZodString;
+        name: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type Grounding = z.infer<typeof GroundingSchema>;
 /**
  * A step of an analysis plan. `PlanStepSchema` (schemas/plan-schemas.ts) narrows
  * this into the planner's output contract and emits it as the `submit_plan`
@@ -37,7 +78,25 @@ export declare const AnalysisStepSchema: z.ZodObject<{
             count: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    grounding: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            grounded: "grounded";
+            ungrounded: "ungrounded";
+            flagged: "flagged";
+        }>;
+        snapshot: z.ZodString;
+        claims: z.ZodArray<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            name: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
     agent: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodNumber>;
     maxSteps: z.ZodNumber;
     description: z.ZodOptional<z.ZodString>;
@@ -74,7 +133,25 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
                 count: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        grounding: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                grounded: "grounded";
+                ungrounded: "ungrounded";
+                flagged: "flagged";
+            }>;
+            snapshot: z.ZodString;
+            claims: z.ZodArray<z.ZodString>;
+            template: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                step: z.ZodString;
+                name: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                source: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
         agent: z.ZodOptional<z.ZodString>;
+        capability: z.ZodOptional<z.ZodString>;
         timeout: z.ZodOptional<z.ZodNumber>;
         maxSteps: z.ZodNumber;
         description: z.ZodOptional<z.ZodString>;
@@ -146,7 +223,25 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     count: z.ZodNumber;
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
+            grounding: z.ZodOptional<z.ZodObject<{
+                status: z.ZodEnum<{
+                    grounded: "grounded";
+                    ungrounded: "ungrounded";
+                    flagged: "flagged";
+                }>;
+                snapshot: z.ZodString;
+                claims: z.ZodArray<z.ZodString>;
+                template: z.ZodOptional<z.ZodString>;
+                settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    step: z.ZodString;
+                    name: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                    source: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
             agent: z.ZodOptional<z.ZodString>;
+            capability: z.ZodOptional<z.ZodString>;
             timeout: z.ZodOptional<z.ZodNumber>;
             maxSteps: z.ZodNumber;
             description: z.ZodOptional<z.ZodString>;
@@ -266,7 +361,25 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
                         count: z.ZodNumber;
                     }, z.core.$strip>>;
                 }, z.core.$strip>>;
+                grounding: z.ZodOptional<z.ZodObject<{
+                    status: z.ZodEnum<{
+                        grounded: "grounded";
+                        ungrounded: "ungrounded";
+                        flagged: "flagged";
+                    }>;
+                    snapshot: z.ZodString;
+                    claims: z.ZodArray<z.ZodString>;
+                    template: z.ZodOptional<z.ZodString>;
+                    settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        step: z.ZodString;
+                        name: z.ZodString;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                        source: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
                 agent: z.ZodOptional<z.ZodString>;
+                capability: z.ZodOptional<z.ZodString>;
                 timeout: z.ZodOptional<z.ZodNumber>;
                 maxSteps: z.ZodNumber;
                 description: z.ZodOptional<z.ZodString>;