spawnfile 0.1.14 → 0.1.18

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

@@ -0,0 +1,33 @@
+import path from "node:path";
+import { z } from "zod";
+import { trainingContextSchema } from "../contract.js";
+import { trainingExecutionSchema } from "../execution.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,
+    execution: trainingExecutionSchema.optional(),
+    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, validateMeasurementRepairOutput } 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, validateMeasurementRepairOutput } from "./prepare.js";
+export { readTrainingWitness, writeTrainingWitness } from "./witness.js";
+export { repairEnvelopeSchema } from "./contract.js";

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

@@ -0,0 +1,382 @@
+import type { TrainingContext } from "../contract.js";
+import type { TrainingImagePlan } from "../preparation/image.js";
+import type { PlannedInput } from "../preparation/inputs.js";
+export declare function validateMeasurementRepairOutput(options: {
+    parent: string;
+    output: string;
+    resume: boolean;
+}): Promise<string>;
+export declare function planMeasurementRepair(options: {
+    parent: string;
+    witness?: string;
+    output: string;
+    auth: string[];
+    image: TrainingImagePlan;
+    inputs: PlannedInput[];
+    context: TrainingContext;
+    resume: boolean;
+}): Promise<{
+    parent: string;
+    witness: {
+        path: string;
+        manifest: {
+            schema: "spawnfile.training-legacy-witness.v1" | "spawnfile.training-witness.v1";
+            parentImage: string;
+            parentPreparationDigest: string;
+            imagePlanDigest: string;
+            config: {
+                version: "spawnfile.training-container.v3" | "spawnfile.training-container.v4" | "spawnfile.training-container.v2";
+                slots: number;
+                dockerContext: string;
+                image: {
+                    ref: string;
+                } | {
+                    build: {
+                        recipe: "daimon-dspy.v1";
+                        nativeImage: string;
+                        pythonImage: string;
+                        platform: "linux/amd64" | "linux/arm64";
+                        paideia: string;
+                        bridge: string;
+                        claude: string;
+                        integration: {
+                            source: string;
+                            entry: string;
+                            execution?: "spawnfile.training-execution.v1" | undefined;
+                        };
+                        compiler?: string | undefined;
+                        grok?: {
+                            source: string;
+                            sha256: string;
+                        } | undefined;
+                        bootstrap?: string | undefined;
+                    };
+                };
+                integration: {
+                    settings: {
+                        input: string;
+                        path: string;
+                    };
+                };
+                inputs: {
+                    id: string;
+                    source: string;
+                    destination: string;
+                    include?: string[] | undefined;
+                    git?: {
+                        revision: string;
+                        overlays: {
+                            source: string;
+                            path: string;
+                            sha256: string;
+                        }[];
+                    } | undefined;
+                }[];
+                output: {
+                    source: string;
+                    destination: "/run/training/output";
+                };
+                auth: {
+                    source: string;
+                    provider: "codex" | "claude";
+                }[];
+                evaluatorRoutes?: {
+                    purpose: "decisions" | "extraction" | "proposals";
+                    provider: "codex-subscription" | "typesafe";
+                    model: string;
+                    maxRequests: number;
+                    maxSpendUsd?: number | undefined;
+                }[] | undefined;
+                evaluatorSecrets?: {
+                    provider: "typesafe";
+                    source: string;
+                }[] | undefined;
+                subjectIsolation?: "codex-native-sandbox" | undefined;
+                broker?: {
+                    maxRunRequests: number;
+                    engine: "grok";
+                    agentId: string;
+                    model: "grok-4.6" | "grok-4.5" | "grok-build";
+                    reasoningEffort: "high" | "medium" | "low";
+                    architecture: "arm64" | "x64";
+                    limits: {
+                        maxRequests: number;
+                        maxTokens: number;
+                        timeoutMs: number;
+                    };
+                    realmVolume: string;
+                    bootstrap: string;
+                    unenforcedBindPolicy?: "refuse" | "profile-only" | undefined;
+                } | undefined;
+            };
+            context: {
+                version: "spawnfile.training-context.v1";
+                producer: {
+                    package: "spawnfile";
+                    version: string;
+                };
+                project: {
+                    root: string;
+                    manifest: string;
+                    sourceDigest: string;
+                };
+                agent: {
+                    id: string;
+                    name: string;
+                    source: string;
+                    runtime: string;
+                    engine: string | null;
+                    model: {
+                        provider: string;
+                        name: string;
+                        authMethod: string;
+                    } | null;
+                };
+                sources: {
+                    sourcePath: string;
+                    destinationPath: string;
+                    sha256: string;
+                }[];
+                documents: {
+                    sourcePath: string;
+                    destinationPath: string;
+                    sha256: string;
+                    role: string;
+                }[];
+                skills: {
+                    sourcePath: string;
+                    destinationPath: string;
+                    sha256: string;
+                    name: string;
+                    ref: string;
+                    requiresMcp: string[];
+                }[];
+                resources: {
+                    id: string;
+                    kind: "volume" | "git" | "bundle";
+                    mount: string;
+                    mode: "readonly" | "mutable";
+                    sharing: "per_agent" | "team";
+                    definitionDigest: string;
+                    pin: string | null;
+                }[];
+                requirements: {
+                    nativeCompilation: true;
+                    isolatedPreparation: true;
+                };
+            };
+            command: {
+                args: string[];
+                env?: Record<string, string> | undefined;
+            };
+            inputs: {
+                id: string;
+                source: string;
+                destination: string;
+                digest: string;
+                staged: string;
+                snapshotDigest: string | null;
+            }[];
+            image: {
+                build: {
+                    recipe: "daimon-dspy.v1";
+                    nativeImage: string;
+                    pythonImage: string;
+                    platform: "linux/amd64" | "linux/arm64";
+                    paideia: string;
+                    bridge: string;
+                    claude: string;
+                    integration: {
+                        source: string;
+                        entry: string;
+                        execution?: "spawnfile.training-execution.v1" | undefined;
+                    };
+                    compiler?: string | undefined;
+                    grok?: {
+                        source: string;
+                        sha256: string;
+                    } | undefined;
+                    bootstrap?: string | undefined;
+                };
+                dockerfile: string;
+                entry: string;
+                brokerEntry: string;
+                files: {
+                    destination: string;
+                    sha256: string;
+                    mode: number;
+                    size: number;
+                }[];
+            };
+            execution?: {
+                version: "spawnfile.training-execution.v1";
+                authoring: {
+                    version: "spawnfile.training-plan.v1";
+                    producer: {
+                        package: "spawnfile";
+                        version: string;
+                    };
+                    project: {
+                        root: string;
+                        manifest: string;
+                    };
+                    agent: {
+                        id: string;
+                        name: string;
+                    };
+                    record: {
+                        keep: string | null;
+                        volumes: {
+                            id: string;
+                            declaredBy: string;
+                        }[];
+                    } | null;
+                    optimizer: {
+                        method: string;
+                        model: string;
+                        variants: number;
+                        keep: number;
+                        budget: {
+                            rounds: number;
+                        };
+                    } | null;
+                    graders: {
+                        sourcePath: string;
+                        path: string;
+                        name: string;
+                        declaredBy: string;
+                    }[];
+                    targets: {
+                        declaredBy: string;
+                        grader: string;
+                        files: {
+                            sourcePath: string;
+                            path: string;
+                            consumers: string[];
+                        }[];
+                        datasets: {
+                            train: {
+                                sourcePath: string;
+                                path: string;
+                                examples: {
+                                    id: string;
+                                    at: string;
+                                    wake: {
+                                        surface: "moltnet";
+                                        room: string;
+                                        from: string;
+                                        text: string;
+                                    };
+                                    overrides: {
+                                        id: string;
+                                        declaredBy: string;
+                                        section: "memory" | "resources" | "networks";
+                                    }[];
+                                }[];
+                            };
+                            validation: {
+                                sourcePath: string;
+                                path: string;
+                                examples: {
+                                    id: string;
+                                    at: string;
+                                    wake: {
+                                        surface: "moltnet";
+                                        room: string;
+                                        from: string;
+                                        text: string;
+                                    };
+                                    overrides: {
+                                        id: string;
+                                        declaredBy: string;
+                                        section: "memory" | "resources" | "networks";
+                                    }[];
+                                }[];
+                            } | null;
+                            test: {
+                                sourcePath: string;
+                                path: string;
+                                examples: {
+                                    id: string;
+                                    at: string;
+                                    wake: {
+                                        surface: "moltnet";
+                                        room: string;
+                                        from: string;
+                                        text: string;
+                                    };
+                                    overrides: {
+                                        id: string;
+                                        declaredBy: string;
+                                        section: "memory" | "resources" | "networks";
+                                    }[];
+                                }[];
+                            };
+                        };
+                    }[];
+                    deadlines?: {
+                        experiment_ms: number;
+                        trial_ms?: number | undefined;
+                    } | undefined;
+                    preparation?: {
+                        hook: string;
+                        history?: string | undefined;
+                    } | undefined;
+                };
+                datasetPins: {
+                    sourcePath: string;
+                    sha256: string;
+                }[];
+                optimizer: {
+                    method: string;
+                    model: string;
+                    variants: number;
+                    keep: number;
+                    budget: {
+                        rounds: number;
+                    };
+                };
+                args: string[];
+                output: string;
+            } | undefined;
+            repair?: {
+                witness: string;
+                parent: string;
+            } | undefined;
+        };
+        digest: string;
+    };
+    compatibility: {
+        components: Record<string, string>;
+        inputs: {
+            [k: string]: string;
+        };
+    };
+    files: import("../preparation/files.js").SealedFile[];
+    command: {
+        schema: "paideia.command-checkpoint.v1";
+        id: string;
+        identity: string;
+        lineage?: {
+            parentId: string;
+            parentIdentity: string;
+            receiptDigest: string;
+        } | undefined;
+    };
+    trainingIdentity: string;
+    checkpoints: Record<string, string>;
+    manifest: {
+        version: string;
+        files: {
+            path: string;
+            sha256: string;
+            size: number;
+        }[];
+    };
+    manifestDigest: string;
+}>;
+export type MeasurementRepairPlan = Awaited<ReturnType<typeof planMeasurementRepair>>;
+export declare function stageMeasurementRepair(plan: MeasurementRepairPlan, staging: string, image: string, canonicalSourceDigest: string, resume: boolean): Promise<{
+    repairPath: string;
+    root: string;
+}>;

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

@@ -0,0 +1,78 @@
+import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { assertInputRoot, copySealed, exactPath, hashJson, sealFile, sealTree, within } from "../preparation/files.js";
+import { readTrainingWitness } from "./witness.js";
+import { verifyTrainingCompatibility } from "./compatibility.js";
+import { repairEnvelopeSchema } from "./contract.js";
+const commandSchema = z.object({ schema: z.literal("paideia.command-checkpoint.v1"), id: z.string().uuid(),
+    identity: z.string().regex(/^[a-f0-9]{64}$/u),
+    lineage: z.object({ parentId: z.string().uuid(), parentIdentity: z.string().regex(/^[a-f0-9]{64}$/u),
+        receiptDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u) }).strict().optional() }).strict();
+export async function validateMeasurementRepairOutput(options) {
+    const parent = await exactPath(options.parent);
+    if (within(parent, options.output) || within(options.output, parent))
+        throw Error("Repair output must be disjoint from parent");
+    if (!options.resume) {
+        try {
+            await lstat(options.output);
+            throw Error("Measurement repair requires a fresh output directory");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    return parent;
+}
+export async function planMeasurementRepair(options) {
+    const parent = await validateMeasurementRepairOutput(options);
+    assertInputRoot(parent, options.auth);
+    const staging = path.join(path.dirname(parent), `.spawnfile-training-preparation-${hashJson(parent).slice(7, 23)}`);
+    const witness = await readTrainingWitness(options.witness ?? path.join(staging, "witness/manifest.json"));
+    const state = JSON.parse(await readFile(path.join(staging, "state.json"), "utf8"));
+    if (state.digest !== witness.manifest.parentPreparationDigest || state.image !== witness.manifest.parentImage)
+        throw Error("Repair parent preparation does not match witness");
+    const compatibility = verifyTrainingCompatibility(witness.manifest, options.image, options.inputs, options.context);
+    compatibility.components["parent-witness"] = witness.digest;
+    const files = [...await sealTree(path.join(parent, "runs"), "runs"), ...await sealTree(path.join(parent, "blobs"), "blobs")];
+    const checkpoints = {};
+    for (const name of ["command", "training", "host", "optimizer"]) {
+        const file = await sealFile(path.join(parent, "checkpoint", `${name}.json`), `checkpoint/${name}.json`);
+        files.push(file);
+        checkpoints[name] = file.sha256;
+    }
+    const command = commandSchema.parse(JSON.parse(await readFile(path.join(parent, "checkpoint/command.json"), "utf8")));
+    const training = JSON.parse(await readFile(path.join(parent, "checkpoint/training.json"), "utf8"));
+    const trainingIdentity = z.string().regex(/^[a-f0-9]{64}$/u).parse(training.state?.identity);
+    const manifest = { version: "paideia.repair-parent.v1", files: files.map(file => ({ path: file.destination, sha256: file.sha256, size: file.size })) };
+    return { parent, witness, compatibility, files, command, trainingIdentity, checkpoints,
+        manifest, manifestDigest: hashJson(manifest) };
+}
+export async function stageMeasurementRepair(plan, staging, image, canonicalSourceDigest, resume) {
+    const root = path.join(staging, "repair-parent"), repairPath = path.join(staging, "repair.json");
+    const compatibility = { version: "spawnfile.daimon-dspy-compatibility.v1", ...plan.compatibility,
+        digest: hashJson(plan.compatibility) };
+    const receipt = repairEnvelopeSchema.shape.receipt.parse({ version: "paideia.measurement-repair.v1",
+        parent: { root: "/run/training/inputs/repair-parent", imageId: plan.witness.manifest.parentImage,
+            experimentId: plan.command.id, executionIdentity: plan.command.identity, manifestDigest: plan.manifestDigest,
+            checkpoints: plan.checkpoints, trainingIdentity: plan.trainingIdentity },
+        current: { imageId: image, canonicalSourceDigest, adapterId: "daimon-native" }, compatibility });
+    const envelope = { receipt, digest: hashJson(receipt) };
+    if (resume) {
+        if (await exactPath(repairPath) !== repairPath || hashJson(JSON.parse(await readFile(repairPath, "utf8"))) !== hashJson(envelope))
+            throw Error("Saved measurement repair receipt changed");
+        if ((await sealFile(path.join(root, "projection-manifest.json"), "manifest")).sha256 !== plan.manifestDigest)
+            throw Error("Saved repair projection changed");
+        for (const file of plan.files)
+            if ((await sealFile(path.join(root, file.destination), file.destination)).sha256 !== file.sha256)
+                throw Error("Saved repair capture changed");
+    }
+    else {
+        await mkdir(root, { mode: 0o700 });
+        await copySealed(plan.files, root);
+        await writeFile(path.join(root, "projection-manifest.json"), JSON.stringify(plan.manifest), { mode: 0o400, flag: "wx" });
+        await writeFile(repairPath, JSON.stringify(envelope), { mode: 0o400, flag: "wx" });
+    }
+    return { repairPath, root };
+}