spawnfile 0.1.17 → 0.1.19

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

@@ -1,6 +1,11 @@
 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;
@@ -20,7 +25,8 @@ export declare function planMeasurementRepair(options: {
             parentPreparationDigest: string;
             imagePlanDigest: string;
             config: {
-                version: "spawnfile.training-container.v3" | "spawnfile.training-container.v2";
+                version: "spawnfile.training-container.v3" | "spawnfile.training-container.v4" | "spawnfile.training-container.v2";
+                slots: number;
                 dockerContext: string;
                 image: {
                     ref: string;
@@ -29,13 +35,14 @@ export declare function planMeasurementRepair(options: {
                         recipe: "daimon-dspy.v1";
                         nativeImage: string;
                         pythonImage: string;
-                        platform: "linux/arm64" | "linux/amd64";
+                        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?: {
@@ -73,7 +80,20 @@ export declare function planMeasurementRepair(options: {
                     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";
@@ -162,13 +182,14 @@ export declare function planMeasurementRepair(options: {
                     recipe: "daimon-dspy.v1";
                     nativeImage: string;
                     pythonImage: string;
-                    platform: "linux/arm64" | "linux/amd64";
+                    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?: {
@@ -187,6 +208,137 @@ export declare function planMeasurementRepair(options: {
                     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;

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

@@ -9,9 +9,8 @@ const commandSchema = z.object({ schema: z.literal("paideia.command-checkpoint.v
     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 planMeasurementRepair(options) {
+export async function validateMeasurementRepairOutput(options) {
     const parent = await exactPath(options.parent);
-    assertInputRoot(parent, options.auth);
     if (within(parent, options.output) || within(options.output, parent))
         throw Error("Repair output must be disjoint from parent");
     if (!options.resume) {
@@ -24,6 +23,11 @@ export async function planMeasurementRepair(options) {
                 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"));

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

@@ -1,4 +1,5 @@
 import type { TrainingContext } from "../contract.js";
+import { type TrainingExecution } from "../execution.js";
 import type { TrainingPreparationConfig } from "../preparation/contract.js";
 import type { TrainingImagePlan } from "../preparation/image.js";
 import type { PlannedInput } from "../preparation/inputs.js";
@@ -10,7 +11,8 @@ export declare function readTrainingWitness(file: string): Promise<{
         parentPreparationDigest: string;
         imagePlanDigest: string;
         config: {
-            version: "spawnfile.training-container.v3" | "spawnfile.training-container.v2";
+            version: "spawnfile.training-container.v3" | "spawnfile.training-container.v4" | "spawnfile.training-container.v2";
+            slots: number;
             dockerContext: string;
             image: {
                 ref: string;
@@ -19,13 +21,14 @@ export declare function readTrainingWitness(file: string): Promise<{
                     recipe: "daimon-dspy.v1";
                     nativeImage: string;
                     pythonImage: string;
-                    platform: "linux/arm64" | "linux/amd64";
+                    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?: {
@@ -63,7 +66,20 @@ export declare function readTrainingWitness(file: string): Promise<{
                 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";
@@ -152,13 +168,14 @@ export declare function readTrainingWitness(file: string): Promise<{
                 recipe: "daimon-dspy.v1";
                 nativeImage: string;
                 pythonImage: string;
-                platform: "linux/arm64" | "linux/amd64";
+                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?: {
@@ -177,6 +194,137 @@ export declare function readTrainingWitness(file: string): Promise<{
                 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;
@@ -192,6 +340,7 @@ export declare function writeTrainingWitness(options: {
     config: TrainingPreparationConfig;
     context: TrainingContext;
     args: readonly string[];
+    execution?: TrainingExecution;
     inputs: PlannedInput[];
     staged: string[];
     snapshots: (string | null)[];

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

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { trainingExecutionIdentity } from "../execution.js";
 import { copySealed, exactPath, fileIdentity, hashJson, sealTree } from "../preparation/files.js";
 import { witnessEnvelopeSchema } from "./contract.js";
 export async function readTrainingWitness(file) {
@@ -18,9 +19,13 @@ export async function readTrainingWitness(file) {
     if (hashJson({ recipe, nativeImage, pythonImage, platform, files: witness.image.files,
         dockerfile: witness.image.dockerfile, entry: witness.image.entry, brokerEntry: witness.image.brokerEntry }) !== witness.imagePlanDigest)
         throw Error("Training witness recipe identity mismatch");
-    const expected = hashJson({ config: raw.manifest && raw.manifest.config,
+    // Validate with the schemas above, but hash the original property order used by preparation.
+    const manifest = raw.manifest;
+    const expected = hashJson({ config: manifest.config,
         sources: witness.inputs.map(input => ({ id: input.id, digest: input.digest })),
-        image: witness.imagePlanDigest, canonical: witness.context.project.sourceDigest, ...(witness.repair ? { repair: witness.repair } : {}) });
+        image: witness.imagePlanDigest, canonical: witness.context.project.sourceDigest,
+        ...(manifest.execution ? { execution: trainingExecutionIdentity(manifest.execution) } : {}),
+        ...(witness.repair ? { repair: witness.repair } : {}) });
     if (expected !== witness.parentPreparationDigest)
         throw Error("Training witness preparation identity mismatch");
     return { ...parsed, path: canonical };
@@ -32,6 +37,7 @@ export async function writeTrainingWitness(options) {
     await copySealed(options.plan.files, path.join(directory, "image-files"));
     const manifest = { schema: "spawnfile.training-witness.v1", parentImage: options.image,
         parentPreparationDigest: options.digest, imagePlanDigest: options.plan.digest, config: options.config,
+        ...(options.execution ? { execution: options.execution } : {}),
         ...(options.repair ? { repair: options.repair } : {}),
         context: options.context, command: { args: [...options.args] },
         inputs: options.inputs.map((input, index) => ({ id: input.id, source: input.source, destination: input.destination,

package/dist/compiler/training/resolution.d.ts

@@ -0,0 +1,25 @@
+import type { TrainingDeclaration, TrainingTarget } from "../../manifest/index.js";
+import type { CompilePlanNode } from "../types.js";
+export interface ResolvedTrainingGrader {
+    sourcePath: string;
+    /** A source key during traversal; a stable node ID in the finished compile plan. */
+    declaredBy: string;
+}
+export interface ResolvedTraining {
+    deadlines?: TrainingDeclaration["deadlines"];
+    preparation?: {
+        hook: string;
+        history?: string;
+    };
+    record?: TrainingDeclaration["record"];
+    optimizer?: TrainingDeclaration["optimizer"];
+    graders: Record<string, ResolvedTrainingGrader>;
+    /** Only this node's targets, with absolute file and dataset paths. */
+    targets: TrainingTarget[];
+}
+/** Resolve declaration-relative paths before any inheritance or shadowing. */
+export declare const resolveTrainingDeclaration: (declaration: TrainingDeclaration | undefined, manifestPath: string, declaredBy: string) => ResolvedTraining | undefined;
+/** Direct team membership only: field merges, local arrays, local targets. */
+export declare const mergeTrainingDeclarations: (inherited: ResolvedTraining | undefined, local: ResolvedTraining | undefined) => ResolvedTraining | undefined;
+/** Provenance uses the same stable IDs as every finished graph consumer. */
+export declare const resolvePlanTrainingSources: (nodes: CompilePlanNode[]) => void;

package/dist/compiler/training/resolution.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { SpawnfileError } from "../../shared/index.js";
+/** Resolve declaration-relative paths before any inheritance or shadowing. */
+export const resolveTrainingDeclaration = (declaration, manifestPath, declaredBy) => {
+    if (declaration === undefined)
+        return undefined;
+    const resolve = (value) => path.resolve(path.dirname(manifestPath), value);
+    return {
+        ...(declaration.deadlines === undefined ? {} : { deadlines: { ...declaration.deadlines } }),
+        ...(declaration.preparation === undefined ? {} : { preparation: { ...declaration.preparation,
+                ...(declaration.preparation.history === undefined ? {} : { history: resolve(declaration.preparation.history) }) } }),
+        ...(declaration.record === undefined ? {} : { record: { ...declaration.record,
+                ...(declaration.record.volumes === undefined ? {} : { volumes: [...declaration.record.volumes] }) } }),
+        ...(declaration.optimizer === undefined ? {} : { optimizer: { ...declaration.optimizer,
+                ...(declaration.optimizer.budget === undefined ? {} : { budget: { ...declaration.optimizer.budget } }) } }),
+        graders: Object.fromEntries(Object.entries(declaration.graders ?? {})
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, value]) => [name, { sourcePath: resolve(value), declaredBy }])),
+        targets: (declaration.targets ?? []).map((target) => ({
+            files: target.files.map(resolve),
+            grader: target.grader,
+            datasets: {
+                train: resolve(target.datasets.train),
+                ...(target.datasets.validation === undefined ? {} : { validation: resolve(target.datasets.validation) }),
+                test: resolve(target.datasets.test)
+            }
+        }))
+    };
+};
+/** Direct team membership only: field merges, local arrays, local targets. */
+export const mergeTrainingDeclarations = (inherited, local) => {
+    const deadlines = inherited?.deadlines === undefined && local?.deadlines === undefined
+        ? undefined : { ...inherited?.deadlines, ...local?.deadlines };
+    const record = inherited?.record === undefined && local?.record === undefined
+        ? undefined : { ...inherited?.record, ...local?.record };
+    const budget = inherited?.optimizer?.budget === undefined && local?.optimizer?.budget === undefined
+        ? undefined : { ...inherited?.optimizer?.budget, ...local?.optimizer?.budget };
+    const optimizer = inherited?.optimizer === undefined && local?.optimizer === undefined
+        ? undefined : { ...inherited?.optimizer, ...local?.optimizer, ...(budget === undefined ? {} : { budget }) };
+    const graders = { ...inherited?.graders, ...local?.graders };
+    const targets = local?.targets ?? [];
+    const preparation = local?.preparation ?? inherited?.preparation;
+    if (deadlines === undefined && preparation === undefined && record === undefined && optimizer === undefined && Object.keys(graders).length === 0 && targets.length === 0) {
+        return undefined;
+    }
+    return {
+        ...(deadlines === undefined ? {} : { deadlines }),
+        ...(preparation === undefined ? {} : { preparation }),
+        ...(record === undefined ? {} : { record }),
+        ...(optimizer === undefined ? {} : { optimizer }),
+        graders: Object.fromEntries(Object.entries(graders).sort(([left], [right]) => left.localeCompare(right))),
+        targets
+    };
+};
+/** Provenance uses the same stable IDs as every finished graph consumer. */
+export const resolvePlanTrainingSources = (nodes) => {
+    const idBySource = new Map(nodes.map((node) => [node.value.source, node.id]));
+    for (const node of nodes) {
+        if (!node.value.training)
+            continue;
+        node.value.training.graders = Object.fromEntries(Object.entries(node.value.training.graders).map(([name, grader]) => {
+            const declaredBy = idBySource.get(grader.declaredBy);
+            if (declaredBy === undefined) {
+                throw new SpawnfileError("compile_error", `Training grader ${name} has unknown declaring source ${grader.declaredBy}`);
+            }
+            return [name, { ...grader, declaredBy }];
+        }));
+    }
+};