spawnfile 0.1.33 → 0.1.34

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

@@ -1,34 +0,0 @@
-import { compatibleWireLiteral } from '../../../shared/index.js';
-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: compatibleWireLiteral("spawnfile.training.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.string().min(1).max(512) }).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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,378 +0,0 @@
-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";
-                        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: "low" | "medium" | "high";
-                    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";
-                    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: "networks" | "memory" | "resources";
-                                    }[];
-                                }[];
-                            };
-                            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: "networks" | "memory" | "resources";
-                                    }[];
-                                }[];
-                            } | 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: "networks" | "memory" | "resources";
-                                    }[];
-                                }[];
-                            };
-                        };
-                    }[];
-                    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: "spawnfile.training.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

@@ -1,84 +0,0 @@
-import { getRegisteredRuntime } from '../../../runtime/registry.js';
-import { compatibleWireLiteral } from '../../../shared/index.js';
-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: compatibleWireLiteral("spawnfile.training.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: "spawnfile.training.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 registered = await getRegisteredRuntime(plan.witness.manifest.context.agent.runtime);
-    const adapterId = registered?.training?.adapterId;
-    if (!adapterId)
-        throw Error("Repair runtime has no registered training adapter");
-    const receipt = repairEnvelopeSchema.shape.receipt.parse({ version: "spawnfile.training.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 }, 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 };
-}