spawnfile 0.1.13 → 0.1.17

package/dist/compiler/training/repair/compatibility.d.ts

@@ -0,0 +1,11 @@
+import type { TrainingContext } from "../contract.js";
+import type { TrainingImagePlan } from "../preparation/image.js";
+import type { PlannedInput } from "../preparation/inputs.js";
+import type { TrainingWitness } from "./contract.js";
+/** Subject and optimizer semantics remain pinned; only evaluation/fork plumbing may change. */
+export declare function verifyTrainingCompatibility(witness: TrainingWitness, current: TrainingImagePlan, inputs: PlannedInput[], context: TrainingContext): {
+    components: Record<string, string>;
+    inputs: {
+        [k: string]: string;
+    };
+};

package/dist/compiler/training/repair/compatibility.js

@@ -0,0 +1,34 @@
+import { fileIdentity, hashJson } from "../preparation/files.js";
+/** Subject and optimizer semantics remain pinned; only evaluation/fork plumbing may change. */
+export function verifyTrainingCompatibility(witness, current, inputs, context) {
+    if (context.agent.runtime !== "daimon" || context.project.sourceDigest !== witness.context.project.sourceDigest ||
+        JSON.stringify(context.agent) !== JSON.stringify(witness.context.agent))
+        throw Error("Repair canonical agent changed");
+    const old = witness.image.files, next = fileIdentity(current.files);
+    const selection = (files, prefix, excludes = []) => {
+        const values = files.filter(file => file.destination.startsWith(prefix) && !excludes.some(value => file.destination === value || (value.endsWith("/") && file.destination.startsWith(value))))
+            .map(file => ({ ...file, destination: file.destination.slice(prefix.length) })).sort((a, b) => a.destination.localeCompare(b.destination));
+        if (!values.length)
+            throw Error(`Repair lacks compatibility evidence for ${prefix}`);
+        return hashJson(values);
+    };
+    const components = {};
+    const compare = (name, previous, updated) => {
+        if (previous !== updated)
+            throw Error(`Repair subject compatibility changed: ${name}`);
+        components[name] = updated;
+    };
+    for (const field of ["nativeImage", "pythonImage", "platform"])
+        compare(field, hashJson(witness.image.build[field]), hashJson(current.build[field]));
+    compare("compiler", selection(old, witness.image.build.compiler ? "compiler/" : "spawnfile/"), selection(next, "compiler/"));
+    for (const [name, prefix] of Object.entries({ integration: "integration/", native: "paideia/dist/src/adapters/daimon-native/",
+        trials: "paideia/dist/src/experiments/trials/" }))
+        compare(name, selection(old, prefix), selection(next, prefix));
+    const excluded = ["bridge/paideia_dspy/checkpoint.py", "bridge/paideia_dspy/protocol.py", "bridge/README.md", "bridge/protocol.md", "bridge/.coverage", "bridge/.pytest_cache/", "bridge/coverage.json"];
+    compare("optimizer", selection(old, "bridge/", excluded), selection(next, "bridge/", excluded));
+    const previousInputs = witness.inputs.map(input => ({ id: input.id, destination: input.destination, digest: input.digest }));
+    const currentInputs = inputs.map(input => ({ id: input.id, destination: input.destination, digest: input.digest }));
+    if (hashJson(previousInputs) !== hashJson(currentInputs))
+        throw Error("Repair evidence or dataset inputs changed");
+    return { components, inputs: Object.fromEntries(currentInputs.map(input => [input.id, input.digest])) };
+}

package/dist/compiler/training/repair/contract.d.ts

@@ -0,0 +1,506 @@
+import { z } from "zod";
+export declare const sha: z.ZodString;
+export declare const fileSchema: z.ZodObject<{
+    destination: z.ZodString;
+    sha256: z.ZodString;
+    mode: z.ZodNumber;
+    size: z.ZodNumber;
+}, z.core.$strict>;
+export declare const witnessSchema: z.ZodObject<{
+    schema: z.ZodEnum<{
+        "spawnfile.training-legacy-witness.v1": "spawnfile.training-legacy-witness.v1";
+        "spawnfile.training-witness.v1": "spawnfile.training-witness.v1";
+    }>;
+    parentImage: z.ZodString;
+    parentPreparationDigest: z.ZodString;
+    imagePlanDigest: z.ZodString;
+    config: z.ZodObject<{
+        version: z.ZodEnum<{
+            "spawnfile.training-container.v3": "spawnfile.training-container.v3";
+            "spawnfile.training-container.v2": "spawnfile.training-container.v2";
+        }>;
+        dockerContext: z.ZodString;
+        image: z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            build: z.ZodObject<{
+                recipe: z.ZodLiteral<"daimon-dspy.v1">;
+                nativeImage: z.ZodString;
+                pythonImage: z.ZodString;
+                platform: z.ZodEnum<{
+                    "linux/arm64": "linux/arm64";
+                    "linux/amd64": "linux/amd64";
+                }>;
+                paideia: z.ZodString;
+                bridge: z.ZodString;
+                claude: z.ZodString;
+                compiler: z.ZodOptional<z.ZodString>;
+                grok: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodString;
+                    sha256: z.ZodString;
+                }, z.core.$strict>>;
+                integration: z.ZodObject<{
+                    source: z.ZodString;
+                    entry: z.ZodString;
+                }, z.core.$strict>;
+                bootstrap: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        integration: z.ZodObject<{
+            settings: z.ZodObject<{
+                input: z.ZodString;
+                path: z.ZodUnion<readonly [z.ZodLiteral<".">, z.ZodString]>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        inputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            destination: z.ZodString;
+            include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            git: z.ZodOptional<z.ZodObject<{
+                revision: z.ZodString;
+                overlays: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    source: z.ZodString;
+                    path: z.ZodString;
+                    sha256: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        output: z.ZodObject<{
+            source: z.ZodString;
+            destination: z.ZodLiteral<"/run/training/output">;
+        }, z.core.$strict>;
+        auth: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            provider: z.ZodEnum<{
+                codex: "codex";
+                claude: "claude";
+            }>;
+        }, z.core.$strict>>;
+        broker: z.ZodOptional<z.ZodObject<{
+            engine: z.ZodLiteral<"grok">;
+            agentId: z.ZodString;
+            model: z.ZodEnum<{
+                "grok-4.6": "grok-4.6";
+                "grok-4.5": "grok-4.5";
+                "grok-build": "grok-build";
+            }>;
+            reasoningEffort: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            architecture: z.ZodEnum<{
+                arm64: "arm64";
+                x64: "x64";
+            }>;
+            limits: z.ZodObject<{
+                maxRequests: z.ZodNumber;
+                maxTokens: z.ZodNumber;
+                timeoutMs: z.ZodNumber;
+            }, z.core.$strict>;
+            realmVolume: z.ZodString;
+            bootstrap: z.ZodString;
+            unenforcedBindPolicy: z.ZodOptional<z.ZodEnum<{
+                refuse: "refuse";
+                "profile-only": "profile-only";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    context: z.ZodObject<{
+        version: z.ZodLiteral<"spawnfile.training-context.v1">;
+        producer: z.ZodObject<{
+            package: z.ZodLiteral<"spawnfile">;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        project: z.ZodObject<{
+            root: z.ZodString;
+            manifest: z.ZodString;
+            sourceDigest: z.ZodString;
+        }, z.core.$strict>;
+        agent: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            source: z.ZodString;
+            runtime: z.ZodString;
+            engine: z.ZodNullable<z.ZodString>;
+            model: z.ZodNullable<z.ZodObject<{
+                provider: z.ZodString;
+                name: z.ZodString;
+                authMethod: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        sources: z.ZodArray<z.ZodObject<{
+            sourcePath: z.ZodString;
+            destinationPath: z.ZodString;
+            sha256: z.ZodString;
+        }, z.core.$strict>>;
+        documents: z.ZodArray<z.ZodObject<{
+            sourcePath: z.ZodString;
+            destinationPath: z.ZodString;
+            sha256: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strict>>;
+        skills: z.ZodArray<z.ZodObject<{
+            sourcePath: z.ZodString;
+            destinationPath: z.ZodString;
+            sha256: z.ZodString;
+            name: z.ZodString;
+            ref: z.ZodString;
+            requiresMcp: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        resources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                volume: "volume";
+                git: "git";
+                bundle: "bundle";
+            }>;
+            mount: z.ZodString;
+            mode: z.ZodEnum<{
+                readonly: "readonly";
+                mutable: "mutable";
+            }>;
+            sharing: z.ZodEnum<{
+                per_agent: "per_agent";
+                team: "team";
+            }>;
+            definitionDigest: z.ZodString;
+            pin: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        requirements: z.ZodObject<{
+            nativeCompilation: z.ZodLiteral<true>;
+            isolatedPreparation: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    command: z.ZodObject<{
+        args: z.ZodArray<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>;
+    inputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        destination: z.ZodString;
+        digest: z.ZodString;
+        staged: z.ZodString;
+        snapshotDigest: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    repair: z.ZodOptional<z.ZodObject<{
+        witness: z.ZodString;
+        parent: z.ZodString;
+    }, z.core.$strict>>;
+    image: z.ZodObject<{
+        build: z.ZodObject<{
+            recipe: z.ZodLiteral<"daimon-dspy.v1">;
+            nativeImage: z.ZodString;
+            pythonImage: z.ZodString;
+            platform: z.ZodEnum<{
+                "linux/arm64": "linux/arm64";
+                "linux/amd64": "linux/amd64";
+            }>;
+            paideia: z.ZodString;
+            bridge: z.ZodString;
+            claude: z.ZodString;
+            compiler: z.ZodOptional<z.ZodString>;
+            grok: z.ZodOptional<z.ZodObject<{
+                source: z.ZodString;
+                sha256: z.ZodString;
+            }, z.core.$strict>>;
+            integration: z.ZodObject<{
+                source: z.ZodString;
+                entry: z.ZodString;
+            }, z.core.$strict>;
+            bootstrap: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        dockerfile: z.ZodString;
+        entry: z.ZodString;
+        brokerEntry: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            destination: z.ZodString;
+            sha256: z.ZodString;
+            mode: z.ZodNumber;
+            size: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TrainingWitness = z.infer<typeof witnessSchema>;
+export declare const witnessEnvelopeSchema: z.ZodObject<{
+    manifest: z.ZodObject<{
+        schema: z.ZodEnum<{
+            "spawnfile.training-legacy-witness.v1": "spawnfile.training-legacy-witness.v1";
+            "spawnfile.training-witness.v1": "spawnfile.training-witness.v1";
+        }>;
+        parentImage: z.ZodString;
+        parentPreparationDigest: z.ZodString;
+        imagePlanDigest: z.ZodString;
+        config: z.ZodObject<{
+            version: z.ZodEnum<{
+                "spawnfile.training-container.v3": "spawnfile.training-container.v3";
+                "spawnfile.training-container.v2": "spawnfile.training-container.v2";
+            }>;
+            dockerContext: z.ZodString;
+            image: z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                build: z.ZodObject<{
+                    recipe: z.ZodLiteral<"daimon-dspy.v1">;
+                    nativeImage: z.ZodString;
+                    pythonImage: z.ZodString;
+                    platform: z.ZodEnum<{
+                        "linux/arm64": "linux/arm64";
+                        "linux/amd64": "linux/amd64";
+                    }>;
+                    paideia: z.ZodString;
+                    bridge: z.ZodString;
+                    claude: z.ZodString;
+                    compiler: z.ZodOptional<z.ZodString>;
+                    grok: z.ZodOptional<z.ZodObject<{
+                        source: z.ZodString;
+                        sha256: z.ZodString;
+                    }, z.core.$strict>>;
+                    integration: z.ZodObject<{
+                        source: z.ZodString;
+                        entry: z.ZodString;
+                    }, z.core.$strict>;
+                    bootstrap: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            integration: z.ZodObject<{
+                settings: z.ZodObject<{
+                    input: z.ZodString;
+                    path: z.ZodUnion<readonly [z.ZodLiteral<".">, z.ZodString]>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            inputs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                source: z.ZodString;
+                destination: z.ZodString;
+                include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                git: z.ZodOptional<z.ZodObject<{
+                    revision: z.ZodString;
+                    overlays: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        source: z.ZodString;
+                        path: z.ZodString;
+                        sha256: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            output: z.ZodObject<{
+                source: z.ZodString;
+                destination: z.ZodLiteral<"/run/training/output">;
+            }, z.core.$strict>;
+            auth: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                provider: z.ZodEnum<{
+                    codex: "codex";
+                    claude: "claude";
+                }>;
+            }, z.core.$strict>>;
+            broker: z.ZodOptional<z.ZodObject<{
+                engine: z.ZodLiteral<"grok">;
+                agentId: z.ZodString;
+                model: z.ZodEnum<{
+                    "grok-4.6": "grok-4.6";
+                    "grok-4.5": "grok-4.5";
+                    "grok-build": "grok-build";
+                }>;
+                reasoningEffort: z.ZodEnum<{
+                    high: "high";
+                    medium: "medium";
+                    low: "low";
+                }>;
+                architecture: z.ZodEnum<{
+                    arm64: "arm64";
+                    x64: "x64";
+                }>;
+                limits: z.ZodObject<{
+                    maxRequests: z.ZodNumber;
+                    maxTokens: z.ZodNumber;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>;
+                realmVolume: z.ZodString;
+                bootstrap: z.ZodString;
+                unenforcedBindPolicy: z.ZodOptional<z.ZodEnum<{
+                    refuse: "refuse";
+                    "profile-only": "profile-only";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        context: z.ZodObject<{
+            version: z.ZodLiteral<"spawnfile.training-context.v1">;
+            producer: z.ZodObject<{
+                package: z.ZodLiteral<"spawnfile">;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            project: z.ZodObject<{
+                root: z.ZodString;
+                manifest: z.ZodString;
+                sourceDigest: z.ZodString;
+            }, z.core.$strict>;
+            agent: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                source: z.ZodString;
+                runtime: z.ZodString;
+                engine: z.ZodNullable<z.ZodString>;
+                model: z.ZodNullable<z.ZodObject<{
+                    provider: z.ZodString;
+                    name: z.ZodString;
+                    authMethod: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            sources: z.ZodArray<z.ZodObject<{
+                sourcePath: z.ZodString;
+                destinationPath: z.ZodString;
+                sha256: z.ZodString;
+            }, z.core.$strict>>;
+            documents: z.ZodArray<z.ZodObject<{
+                sourcePath: z.ZodString;
+                destinationPath: z.ZodString;
+                sha256: z.ZodString;
+                role: z.ZodString;
+            }, z.core.$strict>>;
+            skills: z.ZodArray<z.ZodObject<{
+                sourcePath: z.ZodString;
+                destinationPath: z.ZodString;
+                sha256: z.ZodString;
+                name: z.ZodString;
+                ref: z.ZodString;
+                requiresMcp: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            resources: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    volume: "volume";
+                    git: "git";
+                    bundle: "bundle";
+                }>;
+                mount: z.ZodString;
+                mode: z.ZodEnum<{
+                    readonly: "readonly";
+                    mutable: "mutable";
+                }>;
+                sharing: z.ZodEnum<{
+                    per_agent: "per_agent";
+                    team: "team";
+                }>;
+                definitionDigest: z.ZodString;
+                pin: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            requirements: z.ZodObject<{
+                nativeCompilation: z.ZodLiteral<true>;
+                isolatedPreparation: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        command: z.ZodObject<{
+            args: z.ZodArray<z.ZodString>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strict>;
+        inputs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodString;
+            destination: z.ZodString;
+            digest: z.ZodString;
+            staged: z.ZodString;
+            snapshotDigest: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        repair: z.ZodOptional<z.ZodObject<{
+            witness: z.ZodString;
+            parent: z.ZodString;
+        }, z.core.$strict>>;
+        image: z.ZodObject<{
+            build: z.ZodObject<{
+                recipe: z.ZodLiteral<"daimon-dspy.v1">;
+                nativeImage: z.ZodString;
+                pythonImage: z.ZodString;
+                platform: z.ZodEnum<{
+                    "linux/arm64": "linux/arm64";
+                    "linux/amd64": "linux/amd64";
+                }>;
+                paideia: z.ZodString;
+                bridge: z.ZodString;
+                claude: z.ZodString;
+                compiler: z.ZodOptional<z.ZodString>;
+                grok: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodString;
+                    sha256: z.ZodString;
+                }, z.core.$strict>>;
+                integration: z.ZodObject<{
+                    source: z.ZodString;
+                    entry: z.ZodString;
+                }, z.core.$strict>;
+                bootstrap: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            dockerfile: z.ZodString;
+            entry: z.ZodString;
+            brokerEntry: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                destination: z.ZodString;
+                sha256: z.ZodString;
+                mode: z.ZodNumber;
+                size: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export declare const repairReceiptSchema: z.ZodObject<{
+    version: z.ZodLiteral<"paideia.measurement-repair.v1">;
+    parent: z.ZodObject<{
+        root: z.ZodLiteral<"/run/training/inputs/repair-parent">;
+        imageId: z.ZodString;
+        experimentId: z.ZodString;
+        executionIdentity: z.ZodString;
+        manifestDigest: z.ZodString;
+        checkpoints: z.ZodObject<{
+            command: z.ZodString;
+            training: z.ZodString;
+            host: z.ZodString;
+            optimizer: z.ZodString;
+        }, z.core.$strict>;
+        trainingIdentity: z.ZodString;
+    }, z.core.$strict>;
+    current: z.ZodObject<{
+        imageId: z.ZodString;
+        canonicalSourceDigest: z.ZodString;
+        adapterId: z.ZodLiteral<"daimon-native">;
+    }, z.core.$strict>;
+    compatibility: z.ZodObject<{
+        version: z.ZodLiteral<"spawnfile.daimon-dspy-compatibility.v1">;
+        digest: z.ZodString;
+        components: z.ZodRecord<z.ZodString, z.ZodString>;
+        inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const repairEnvelopeSchema: z.ZodObject<{
+    receipt: z.ZodObject<{
+        version: z.ZodLiteral<"paideia.measurement-repair.v1">;
+        parent: z.ZodObject<{
+            root: z.ZodLiteral<"/run/training/inputs/repair-parent">;
+            imageId: z.ZodString;
+            experimentId: z.ZodString;
+            executionIdentity: z.ZodString;
+            manifestDigest: z.ZodString;
+            checkpoints: z.ZodObject<{
+                command: z.ZodString;
+                training: z.ZodString;
+                host: z.ZodString;
+                optimizer: z.ZodString;
+            }, z.core.$strict>;
+            trainingIdentity: z.ZodString;
+        }, z.core.$strict>;
+        current: z.ZodObject<{
+            imageId: z.ZodString;
+            canonicalSourceDigest: z.ZodString;
+            adapterId: z.ZodLiteral<"daimon-native">;
+        }, z.core.$strict>;
+        compatibility: z.ZodObject<{
+            version: z.ZodLiteral<"spawnfile.daimon-dspy-compatibility.v1">;
+            digest: z.ZodString;
+            components: z.ZodRecord<z.ZodString, z.ZodString>;
+            inputs: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export type RepairEnvelope = z.infer<typeof repairEnvelopeSchema>;

package/dist/compiler/training/repair/contract.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { z } from "zod";
+import { trainingContextSchema } from "../contract.js";
+import { trainingPreparationSchema, trainingBuildSchema } from "../preparation/contract.js";
+export const sha = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const relative = z.string().min(1).refine(value => !path.posix.isAbsolute(value) && !value.includes("\\") &&
+    value.split("/").every(part => part !== "." && part !== ".." && part !== ""));
+export const fileSchema = z.object({ destination: relative, sha256: sha, mode: z.number().int().min(0).max(511),
+    size: z.number().int().min(0).max(536870912) }).strict();
+export const witnessSchema = z.object({
+    schema: z.enum(["spawnfile.training-legacy-witness.v1", "spawnfile.training-witness.v1"]),
+    parentImage: sha, parentPreparationDigest: sha, imagePlanDigest: sha,
+    config: trainingPreparationSchema, context: trainingContextSchema,
+    command: z.object({ args: z.array(z.string()), env: z.record(z.string(), z.string()).optional() }).strict(),
+    inputs: z.array(z.object({ id: z.string(), source: z.string(), destination: z.string(), digest: sha,
+        staged: z.string(), snapshotDigest: sha.nullable() }).strict()),
+    repair: z.object({ witness: sha, parent: sha }).strict().optional(),
+    image: z.object({ build: trainingBuildSchema, dockerfile: z.string(), entry: z.string(), brokerEntry: z.string(), files: z.array(fileSchema).min(1).max(10000) }).strict()
+}).strict();
+export const witnessEnvelopeSchema = z.object({ manifest: witnessSchema, digest: sha }).strict();
+export const repairReceiptSchema = z.object({
+    version: z.literal("paideia.measurement-repair.v1"),
+    parent: z.object({ root: z.literal("/run/training/inputs/repair-parent"), imageId: sha,
+        experimentId: z.string().uuid(), executionIdentity: z.string().regex(/^[a-f0-9]{64}$/u), manifestDigest: sha,
+        checkpoints: z.object({ command: sha, training: sha, host: sha, optimizer: sha }).strict(),
+        trainingIdentity: z.string().regex(/^[a-f0-9]{64}$/u) }).strict(),
+    current: z.object({ imageId: sha, canonicalSourceDigest: sha, adapterId: z.literal("daimon-native") }).strict(),
+    compatibility: z.object({ version: z.literal("spawnfile.daimon-dspy-compatibility.v1"), digest: sha,
+        components: z.record(z.string(), sha), inputs: z.record(z.string(), sha) }).strict()
+}).strict();
+export const repairEnvelopeSchema = z.object({ receipt: repairReceiptSchema, digest: sha }).strict();

package/dist/compiler/training/repair/index.d.ts

@@ -0,0 +1,3 @@
+export { planMeasurementRepair, stageMeasurementRepair } from "./prepare.js";
+export { readTrainingWitness, writeTrainingWitness } from "./witness.js";
+export { repairEnvelopeSchema } from "./contract.js";

package/dist/compiler/training/repair/index.js

@@ -0,0 +1,3 @@
+export { planMeasurementRepair, stageMeasurementRepair } from "./prepare.js";
+export { readTrainingWitness, writeTrainingWitness } from "./witness.js";
+export { repairEnvelopeSchema } from "./contract.js";