opencode-swarm 7.155.0 → 7.157.0

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 {};

package/dist/harness/factory.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { type HarnessBlueprintV1, type HarnessConstraintsV1, type ToolSpecV1 } from './contracts.js';
+import { loadHarnessPromptArtifact } from './store.js';
+declare const RuntimeAgentDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodObject<{
+        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.ZodString;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    }, z.core.$strict>;
+    harnessPromptProvenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            candidate: "candidate";
+            static: "static";
+        }>;
+        promptId: z.ZodString;
+        sha256: z.ZodString;
+        candidateId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RuntimeAgentDefinition = z.infer<typeof RuntimeAgentDefinitionSchema>;
+export declare function computeRuntimeDefinitionsHash(runtimeDefinitions: readonly RuntimeAgentDefinition[]): string;
+export declare function createToolFactory(registeredToolIds: readonly string[]): {
+    projectTools(toolIds: readonly string[]): ToolSpecV1[];
+    materializeTools(tools: readonly ToolSpecV1[]): string[];
+};
+export declare function createAgentFactory(options: {
+    runtimeDefinitions: readonly RuntimeAgentDefinition[];
+    registeredToolIds: readonly string[];
+    defaultConstraints?: HarnessConstraintsV1;
+}): {
+    definitionsHash: string;
+    projectBlueprint(args: {
+        blueprintId: string;
+        agentNames?: readonly string[];
+        defaultAgent?: string;
+        constraints?: HarnessConstraintsV1;
+    }): HarnessBlueprintV1;
+    materializeBlueprint(blueprint: HarnessBlueprintV1, options?: {
+        directory?: string;
+    }): RuntimeAgentDefinition[];
+};
+export declare const _factoryInternals: {
+    loadHarnessPromptArtifact: typeof loadHarnessPromptArtifact;
+};
+export {};

package/dist/harness/hash.d.ts

@@ -0,0 +1,4 @@
+export declare function canonicalJson(value: unknown): string;
+export declare function sha256(value: string | Uint8Array): string;
+export declare function canonicalHash(value: unknown): string;
+export declare function contentHashWithout<T extends Record<string, unknown>>(value: T, keys: readonly (keyof T)[]): string;

package/dist/harness/index.d.ts

@@ -0,0 +1,6 @@
+export * from './contracts.js';
+export * from './factory.js';
+export * from './hash.js';
+export * from './patch.js';
+export * from './source-candidate.js';
+export * from './store.js';

package/dist/harness/patch.d.ts

@@ -0,0 +1,3 @@
+import { type BlueprintPatchOperationV1, type HarnessBlueprintV1 } from './contracts.js';
+export declare function deriveBlueprintPatchRiskTier(operations: readonly BlueprintPatchOperationV1[]): 'low' | 'medium' | 'high';
+export declare function applyBlueprintPatch(base: HarnessBlueprintV1, patch: unknown): HarnessBlueprintV1;

package/dist/harness/public-api.d.ts

@@ -0,0 +1,105 @@
+import type { AgentDefinition } from '../agents/index.js';
+import { type HarnessBlueprintV1, parseHarnessBlueprint } from './contracts.js';
+import { applyBlueprintPatch } from './patch.js';
+import { validateSourceCandidate } from './source-candidate.js';
+import { activateHarnessCandidate, auditHarnessLedger, listHarnessHistory, loadHarnessCurrent, recordHarnessCandidate, recoverHarnessCorruptTail, rollbackHarnessVersion, saveHarnessVersion } from './store.js';
+declare function projectStaticBlueprint(agents: Record<string, AgentDefinition>): {
+    v: 1;
+    blueprintId: string;
+    definitionsHash: string;
+    tools: {
+        v: 1;
+        toolId: string;
+        description?: string | undefined;
+    }[];
+    agents: {
+        v: 1;
+        agentName: string;
+        mode: "primary" | "subagent";
+        temperature: number;
+        prompt: {
+            v: 1;
+            promptId: string;
+            ref: string;
+            sha256: string;
+        };
+        tools: string[];
+        description?: string | undefined;
+        model?: string | undefined;
+        variant?: string | undefined;
+        reasoning?: {
+            effort: "none" | "low" | "medium" | "high" | "max" | "xhigh" | "minimal" | "ultra";
+        } | undefined;
+        thinking?: {
+            type: "enabled" | "disabled";
+            budget_tokens?: number | undefined;
+        } | undefined;
+        disabledTools?: string[] | undefined;
+    }[];
+    orchestration: {
+        v: 1;
+        defaultAgent: string;
+        activation: "manual";
+        execution: "disabled";
+        multiSwarm: boolean;
+    };
+    constraints: {
+        v: 1;
+        sourceAllowlist: string[];
+        extraProtectedPaths: string[];
+        maxPatchBytes: number;
+        maxFiles: number;
+        maxFileBytes: number;
+        maxTotalBytes: number;
+        maxChangedLines: number;
+        maxVersions: number;
+        maxReplayRecords: number;
+        maxOutputBytes: number;
+    };
+    contentHash: string;
+};
+declare function diffHarnessBlueprints(left: HarnessBlueprintV1, right: HarnessBlueprintV1): {
+    changes: Record<string, {
+        before: unknown;
+        after: unknown;
+    }>;
+    summary: {
+        changeCount: number;
+        changedKeys: string[];
+    };
+};
+/**
+ * Callable package namespace for explicit HarnessOpt consumers. Importing it is
+ * pure; no filesystem, Git, agent, or activation work occurs until a method is
+ * invoked. The live plugin manifest never calls this function during init.
+ */
+export declare const harnessMutationV1: (() => /*elided*/ any & {
+    validateBlueprint: typeof parseHarnessBlueprint;
+    projectStaticBlueprint: typeof projectStaticBlueprint;
+    applyPatchSet: typeof applyBlueprintPatch;
+    validateSourceCandidate: typeof validateSourceCandidate;
+    saveCandidate: typeof recordHarnessCandidate;
+    saveVersion: typeof saveHarnessVersion;
+    activate: typeof activateHarnessCandidate;
+    rollback: typeof rollbackHarnessVersion;
+    current: typeof loadHarnessCurrent;
+    history: typeof listHarnessHistory;
+    diff: typeof diffHarnessBlueprints;
+    auditLedger: typeof auditHarnessLedger;
+    recoverCorruptTail: typeof recoverHarnessCorruptTail;
+}) & {
+    validateBlueprint: typeof parseHarnessBlueprint;
+    projectStaticBlueprint: typeof projectStaticBlueprint;
+    applyPatchSet: typeof applyBlueprintPatch;
+    validateSourceCandidate: typeof validateSourceCandidate;
+    saveCandidate: typeof recordHarnessCandidate;
+    saveVersion: typeof saveHarnessVersion;
+    activate: typeof activateHarnessCandidate;
+    rollback: typeof rollbackHarnessVersion;
+    current: typeof loadHarnessCurrent;
+    history: typeof listHarnessHistory;
+    diff: typeof diffHarnessBlueprints;
+    auditLedger: typeof auditHarnessLedger;
+    recoverCorruptTail: typeof recoverHarnessCorruptTail;
+};
+export {};