opencode-swarm 7.155.0 → 7.156.0

package/dist/commands/registry.d.ts

@@ -1,5 +1,5 @@
 import type { AgentDefinition } from '../agents/index.js';
-import type { AutoReviewConfig } from '../config/schema.js';
+import type { AutoReviewConfig, PluginConfig } from '../config/schema.js';
 import type { EvaluationModelDispatcher } from '../evaluation/model-dispatcher.js';
 import type { ReviewModelDispatcher } from '../review/contracts.js';
 import type { ReviewAgentModelRegistry } from '../review/runtime.js';
@@ -14,6 +14,7 @@ export type CommandContext = {
     args: string[];
     sessionID: string;
     agents: Record<string, AgentDefinition>;
+    config?: PluginConfig;
     packageRoot?: string;
     /**
      * Dispatch path identifier. Issue #890: forensic audit trail for
@@ -73,6 +74,118 @@ export type CommandEntry = {
     toolNoArgs?: boolean;
 };
 export declare const COMMAND_REGISTRY: {
+    readonly 'blueprint validate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Validate a declarative harness blueprint or atomic blueprint patch";
+        readonly args: "<project-relative-json>";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'blueprint current': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show the ledger-derived current harness blueprint projection";
+        readonly args: "";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'blueprint history': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show bounded hash-verified harness version history";
+        readonly args: "[--limit <1..100>]";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'blueprint diff': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Compare two stored harness blueprint versions";
+        readonly args: "<from-version> <to-version>";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'blueprint export': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Export a canonical stored harness blueprint";
+        readonly args: "[version]";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'harness candidate validate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Validate an inert harness candidate manifest";
+        readonly args: "<project-relative-json>";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'harness candidate show': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show bounded harness candidate metadata without raw patch content";
+        readonly args: "<candidate-id>";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'harness candidate diff': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Show candidate file and blueprint-change metadata without raw patch content";
+        readonly args: "<candidate-id>";
+        readonly category: "utility";
+        readonly toolPolicy: "none";
+    };
+    readonly 'blueprint-validate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for blueprint validate";
+        readonly category: "utility";
+        readonly aliasOf: "blueprint validate";
+        readonly deprecated: true;
+    };
+    readonly 'blueprint-current': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for blueprint current";
+        readonly category: "utility";
+        readonly aliasOf: "blueprint current";
+        readonly deprecated: true;
+    };
+    readonly 'blueprint-history': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for blueprint history";
+        readonly category: "utility";
+        readonly aliasOf: "blueprint history";
+        readonly deprecated: true;
+    };
+    readonly 'blueprint-diff': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for blueprint diff";
+        readonly category: "utility";
+        readonly aliasOf: "blueprint diff";
+        readonly deprecated: true;
+    };
+    readonly 'blueprint-export': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for blueprint export";
+        readonly category: "utility";
+        readonly aliasOf: "blueprint export";
+        readonly deprecated: true;
+    };
+    readonly 'harness-candidate-validate': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for harness candidate validate";
+        readonly category: "utility";
+        readonly aliasOf: "harness candidate validate";
+        readonly deprecated: true;
+    };
+    readonly 'harness-candidate-show': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for harness candidate show";
+        readonly category: "utility";
+        readonly aliasOf: "harness candidate show";
+        readonly deprecated: true;
+    };
+    readonly 'harness-candidate-diff': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "TUI shortcut alias for harness candidate diff";
+        readonly category: "utility";
+        readonly aliasOf: "harness candidate diff";
+        readonly deprecated: true;
+    };
     readonly 'acknowledge-spec-drift': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Acknowledge that the spec has drifted from the plan and suppress further warnings";

package/dist/config/schema.d.ts

@@ -1003,6 +1003,27 @@ export declare const SkillPropagationConfigSchema: z.ZodObject<{
     audiences: z.ZodDefault<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
 }, z.core.$strip>;
 export type SkillPropagationConfig = z.infer<typeof SkillPropagationConfigSchema>;
+/**
+ * Declarative HarnessOpt mutation policy (issue #1825).
+ *
+ * This block is consumed only by explicit harness API/command calls. It does
+ * not enable activation, optimization, init-time scans, or candidate execution.
+ */
+export declare const HarnessEvolutionConfigSchema: z.ZodObject<{
+    source_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    extra_protected_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    max_patch_bytes: z.ZodDefault<z.ZodNumber>;
+    max_files: z.ZodDefault<z.ZodNumber>;
+    max_file_bytes: z.ZodDefault<z.ZodNumber>;
+    max_total_bytes: z.ZodDefault<z.ZodNumber>;
+    max_changed_lines: z.ZodDefault<z.ZodNumber>;
+    max_versions: z.ZodDefault<z.ZodNumber>;
+    max_inactive_candidates: z.ZodDefault<z.ZodNumber>;
+    max_replay_records: z.ZodDefault<z.ZodNumber>;
+    max_output_bytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type HarnessEvolutionConfig = z.infer<typeof HarnessEvolutionConfigSchema>;
+export declare const DEFAULT_HARNESS_EVOLUTION_CONFIG: HarnessEvolutionConfig;
 export declare const SkillImproverConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -2516,6 +2537,19 @@ export declare const PluginConfigSchema: z.ZodObject<{
         }>>;
         allow_deterministic_fallback: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    harness_evolution: z.ZodOptional<z.ZodObject<{
+        source_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        extra_protected_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        max_patch_bytes: z.ZodDefault<z.ZodNumber>;
+        max_files: z.ZodDefault<z.ZodNumber>;
+        max_file_bytes: z.ZodDefault<z.ZodNumber>;
+        max_total_bytes: z.ZodDefault<z.ZodNumber>;
+        max_changed_lines: z.ZodDefault<z.ZodNumber>;
+        max_versions: z.ZodDefault<z.ZodNumber>;
+        max_inactive_candidates: z.ZodDefault<z.ZodNumber>;
+        max_replay_records: z.ZodDefault<z.ZodNumber>;
+        max_output_bytes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     spec_writer: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         model: z.ZodDefault<z.ZodNullable<z.ZodString>>;

package/dist/harness/contracts.d.ts

@@ -0,0 +1,492 @@
+import { z } from 'zod';
+declare const RiskTierSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+export declare const HarnessIdentifierSchema: z.ZodString;
+export declare const HarnessSha256Schema: z.ZodString;
+export declare const HarnessRelativePathSchema: z.ZodString;
+export declare const HarnessRiskTierSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+declare const PromptArtifactProvenanceV1Schema: z.ZodObject<{
+    source: z.ZodLiteral<"candidate">;
+    origin: z.ZodString;
+}, z.core.$strict>;
+export type PromptArtifactProvenanceV1 = z.infer<typeof PromptArtifactProvenanceV1Schema>;
+export declare const PromptArtifactV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    promptId: z.ZodString;
+    candidateId: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodNumber;
+    mediaType: z.ZodLiteral<"text/plain; charset=utf-8">;
+    content: z.ZodString;
+    provenance: z.ZodObject<{
+        source: z.ZodLiteral<"candidate">;
+        origin: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PromptArtifactV1 = z.infer<typeof PromptArtifactV1Schema>;
+export declare const PromptBindingV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    promptId: z.ZodString;
+    ref: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+export type PromptBindingV1 = z.infer<typeof PromptBindingV1Schema>;
+export declare const ToolSpecV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    toolId: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ToolSpecV1 = z.infer<typeof ToolSpecV1Schema>;
+export declare const AgentBlueprintV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    agentName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        primary: "primary";
+        subagent: "subagent";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    variant: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        effort: z.ZodEnum<{
+            none: "none";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            max: "max";
+            xhigh: "xhigh";
+            minimal: "minimal";
+            ultra: "ultra";
+        }>;
+    }, z.core.$strict>>;
+    thinking: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            enabled: "enabled";
+            disabled: "disabled";
+        }>;
+        budget_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    temperature: z.ZodNumber;
+    prompt: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        promptId: z.ZodString;
+        ref: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>;
+    tools: z.ZodArray<z.ZodString>;
+    disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentBlueprintV1 = z.infer<typeof AgentBlueprintV1Schema>;
+export declare const OrchestrationSpecV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    defaultAgent: z.ZodString;
+    activation: z.ZodEnum<{
+        manual: "manual";
+    }>;
+    execution: z.ZodEnum<{
+        disabled: "disabled";
+    }>;
+    multiSwarm: z.ZodBoolean;
+}, z.core.$strict>;
+export type OrchestrationSpecV1 = z.infer<typeof OrchestrationSpecV1Schema>;
+export declare const HarnessConstraintsV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    sourceAllowlist: z.ZodArray<z.ZodString>;
+    extraProtectedPaths: z.ZodArray<z.ZodString>;
+    maxPatchBytes: z.ZodNumber;
+    maxFiles: z.ZodNumber;
+    maxFileBytes: z.ZodNumber;
+    maxTotalBytes: z.ZodNumber;
+    maxChangedLines: z.ZodNumber;
+    maxVersions: z.ZodNumber;
+    maxReplayRecords: z.ZodNumber;
+    maxOutputBytes: z.ZodNumber;
+}, z.core.$strict>;
+export type HarnessConstraintsV1 = z.infer<typeof HarnessConstraintsV1Schema>;
+export declare const DEFAULT_HARNESS_CONSTRAINTS_V1: HarnessConstraintsV1;
+export declare const HarnessBlueprintV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    blueprintId: z.ZodString;
+    definitionsHash: z.ZodString;
+    tools: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        toolId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    agents: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        agentName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mode: z.ZodEnum<{
+            primary: "primary";
+            subagent: "subagent";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        reasoning: z.ZodOptional<z.ZodObject<{
+            effort: z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                max: "max";
+                xhigh: "xhigh";
+                minimal: "minimal";
+                ultra: "ultra";
+            }>;
+        }, z.core.$strict>>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                enabled: "enabled";
+                disabled: "disabled";
+            }>;
+            budget_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        temperature: z.ZodNumber;
+        prompt: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            promptId: z.ZodString;
+            ref: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>;
+        tools: z.ZodArray<z.ZodString>;
+        disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    orchestration: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        defaultAgent: z.ZodString;
+        activation: z.ZodEnum<{
+            manual: "manual";
+        }>;
+        execution: z.ZodEnum<{
+            disabled: "disabled";
+        }>;
+        multiSwarm: z.ZodBoolean;
+    }, z.core.$strict>;
+    constraints: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        sourceAllowlist: z.ZodArray<z.ZodString>;
+        extraProtectedPaths: z.ZodArray<z.ZodString>;
+        maxPatchBytes: z.ZodNumber;
+        maxFiles: z.ZodNumber;
+        maxFileBytes: z.ZodNumber;
+        maxTotalBytes: z.ZodNumber;
+        maxChangedLines: z.ZodNumber;
+        maxVersions: z.ZodNumber;
+        maxReplayRecords: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type HarnessBlueprintV1 = z.infer<typeof HarnessBlueprintV1Schema>;
+export declare const HarnessCandidateFileV1Schema: z.ZodObject<{
+    relativePath: z.ZodString;
+    oldRelativePath: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodEnum<{
+        mode: "mode";
+        rename: "rename";
+        copy: "copy";
+        add: "add";
+        delete: "delete";
+        modify: "modify";
+    }>>;
+    trackedMode: z.ZodString;
+    afterMode: z.ZodOptional<z.ZodString>;
+    beforeSha256: z.ZodString;
+    afterSha256: z.ZodString;
+    bytesBefore: z.ZodNumber;
+    bytesAfter: z.ZodNumber;
+    addedLines: z.ZodNumber;
+    removedLines: z.ZodNumber;
+    changedLines: z.ZodNumber;
+}, z.core.$strict>;
+export type HarnessCandidateFileV1 = z.infer<typeof HarnessCandidateFileV1Schema>;
+export declare const HarnessCandidateManifestV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    candidateId: z.ZodString;
+    baseSha: z.ZodString;
+    origin: z.ZodString;
+    patchSha256: z.ZodString;
+    promptArtifactHashes: z.ZodArray<z.ZodString>;
+    manifestHash: z.ZodString;
+    riskTier: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    approvedPaths: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        relativePath: z.ZodString;
+        oldRelativePath: z.ZodOptional<z.ZodString>;
+        operation: z.ZodOptional<z.ZodEnum<{
+            mode: "mode";
+            rename: "rename";
+            copy: "copy";
+            add: "add";
+            delete: "delete";
+            modify: "modify";
+        }>>;
+        trackedMode: z.ZodString;
+        afterMode: z.ZodOptional<z.ZodString>;
+        beforeSha256: z.ZodString;
+        afterSha256: z.ZodString;
+        bytesBefore: z.ZodNumber;
+        bytesAfter: z.ZodNumber;
+        addedLines: z.ZodNumber;
+        removedLines: z.ZodNumber;
+        changedLines: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HarnessCandidateManifestV1 = z.infer<typeof HarnessCandidateManifestV1Schema>;
+export declare const BlueprintPatchOperationV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"upsert_prompt">;
+    fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+    expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    prompt: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        promptId: z.ZodString;
+        candidateId: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodLiteral<"text/plain; charset=utf-8">;
+        content: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodLiteral<"candidate">;
+            origin: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"upsert_tool">;
+    fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+    expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    tool: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        toolId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"remove_tool">;
+    fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+    expectedFieldHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"upsert_agent">;
+    fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+    expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    agent: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        agentName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mode: z.ZodEnum<{
+            primary: "primary";
+            subagent: "subagent";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        variant: z.ZodOptional<z.ZodString>;
+        reasoning: z.ZodOptional<z.ZodObject<{
+            effort: z.ZodEnum<{
+                none: "none";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                max: "max";
+                xhigh: "xhigh";
+                minimal: "minimal";
+                ultra: "ultra";
+            }>;
+        }, z.core.$strict>>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                enabled: "enabled";
+                disabled: "disabled";
+            }>;
+            budget_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        temperature: z.ZodNumber;
+        prompt: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            promptId: z.ZodString;
+            ref: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>;
+        tools: z.ZodArray<z.ZodString>;
+        disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"remove_agent">;
+    fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+    expectedFieldHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"replace_orchestration">;
+    fieldPath: z.ZodLiteral<"orchestration">;
+    expectedFieldHash: z.ZodString;
+    orchestration: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        defaultAgent: z.ZodString;
+        activation: z.ZodEnum<{
+            manual: "manual";
+        }>;
+        execution: z.ZodEnum<{
+            disabled: "disabled";
+        }>;
+        multiSwarm: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"replace_constraints">;
+    fieldPath: z.ZodLiteral<"constraints">;
+    expectedFieldHash: z.ZodString;
+    constraints: z.ZodObject<{
+        v: z.ZodLiteral<1>;
+        sourceAllowlist: z.ZodArray<z.ZodString>;
+        extraProtectedPaths: z.ZodArray<z.ZodString>;
+        maxPatchBytes: z.ZodNumber;
+        maxFiles: z.ZodNumber;
+        maxFileBytes: z.ZodNumber;
+        maxTotalBytes: z.ZodNumber;
+        maxChangedLines: z.ZodNumber;
+        maxVersions: z.ZodNumber;
+        maxReplayRecords: z.ZodNumber;
+        maxOutputBytes: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>], "op">;
+export type BlueprintPatchOperationV1 = z.infer<typeof BlueprintPatchOperationV1Schema>;
+export declare const BlueprintPatchV1Schema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    patchId: z.ZodString;
+    expectedBaseHash: z.ZodString;
+    expectedResultHash: z.ZodString;
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"upsert_prompt">;
+        fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+        expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        prompt: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            promptId: z.ZodString;
+            candidateId: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodNumber;
+            mediaType: z.ZodLiteral<"text/plain; charset=utf-8">;
+            content: z.ZodString;
+            provenance: z.ZodObject<{
+                source: z.ZodLiteral<"candidate">;
+                origin: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"upsert_tool">;
+        fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+        expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        tool: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            toolId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"remove_tool">;
+        fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+        expectedFieldHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"upsert_agent">;
+        fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+        expectedFieldHash: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        agent: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            agentName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            mode: z.ZodEnum<{
+                primary: "primary";
+                subagent: "subagent";
+            }>;
+            model: z.ZodOptional<z.ZodString>;
+            variant: z.ZodOptional<z.ZodString>;
+            reasoning: z.ZodOptional<z.ZodObject<{
+                effort: z.ZodEnum<{
+                    none: "none";
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    max: "max";
+                    xhigh: "xhigh";
+                    minimal: "minimal";
+                    ultra: "ultra";
+                }>;
+            }, z.core.$strict>>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    enabled: "enabled";
+                    disabled: "disabled";
+                }>;
+                budget_tokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            temperature: z.ZodNumber;
+            prompt: z.ZodObject<{
+                v: z.ZodLiteral<1>;
+                promptId: z.ZodString;
+                ref: z.ZodString;
+                sha256: z.ZodString;
+            }, z.core.$strict>;
+            tools: z.ZodArray<z.ZodString>;
+            disabledTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"remove_agent">;
+        fieldPath: z.ZodUnion<readonly [z.ZodLiteral<"orchestration">, z.ZodLiteral<"constraints">, z.ZodString]>;
+        expectedFieldHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"replace_orchestration">;
+        fieldPath: z.ZodLiteral<"orchestration">;
+        expectedFieldHash: z.ZodString;
+        orchestration: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            defaultAgent: z.ZodString;
+            activation: z.ZodEnum<{
+                manual: "manual";
+            }>;
+            execution: z.ZodEnum<{
+                disabled: "disabled";
+            }>;
+            multiSwarm: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"replace_constraints">;
+        fieldPath: z.ZodLiteral<"constraints">;
+        expectedFieldHash: z.ZodString;
+        constraints: z.ZodObject<{
+            v: z.ZodLiteral<1>;
+            sourceAllowlist: z.ZodArray<z.ZodString>;
+            extraProtectedPaths: z.ZodArray<z.ZodString>;
+            maxPatchBytes: z.ZodNumber;
+            maxFiles: z.ZodNumber;
+            maxFileBytes: z.ZodNumber;
+            maxTotalBytes: z.ZodNumber;
+            maxChangedLines: z.ZodNumber;
+            maxVersions: z.ZodNumber;
+            maxReplayRecords: z.ZodNumber;
+            maxOutputBytes: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "op">>;
+}, z.core.$strict>;
+export type BlueprintPatchV1 = z.infer<typeof BlueprintPatchV1Schema>;
+export declare function computePromptArtifactHash(value: Omit<PromptArtifactV1, 'sha256'> | PromptArtifactV1): string;
+export declare function computePromptBindingHash(value: PromptBindingV1): string;
+export declare function computeHarnessBlueprintHash(value: Omit<HarnessBlueprintV1, 'contentHash'> | HarnessBlueprintV1): string;
+export declare function computeHarnessCandidateManifestHash(value: Omit<HarnessCandidateManifestV1, 'manifestHash' | 'riskTier'> | HarnessCandidateManifestV1): string;
+export declare function computeBlueprintPatchHash(value: BlueprintPatchV1): string;
+export declare function deriveHarnessCandidateFloors(value: Pick<HarnessCandidateManifestV1, 'files'>): {
+    maxFilesFloor: number;
+    maxFileBytesFloor: number;
+    maxTotalBytesFloor: number;
+    maxChangedLinesFloor: number;
+};
+export declare function deriveHarnessCandidateRiskTier(value: Pick<HarnessCandidateManifestV1, 'files'>): z.infer<typeof RiskTierSchema>;
+export declare function parsePromptArtifact(value: unknown): PromptArtifactV1;
+export declare function parseHarnessBlueprint(value: unknown): HarnessBlueprintV1;
+export declare function parseHarnessCandidateManifest(value: unknown): HarnessCandidateManifestV1;
+export declare function parseBlueprintPatch(value: unknown): BlueprintPatchV1;
+export {};