spawnfile 0.1.25 → 0.1.28

package/dist/compiler/training/preparation/broker.js

@@ -1,3 +1,4 @@
+import { DAIMON_BROKER_ENGINE_ID } from "../../../runtime/daimon/index.js";
 import { createHash } from "node:crypto";
 import { lstat, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -63,5 +64,5 @@ export const prepareTrainingBroker = async (broker, root, staging, write, slots
     const declarationPath = path.join(staging, "training-broker.json");
     if (write)
         await writeFile(declarationPath, `${JSON.stringify(declaration)}\n`, { mode: 0o444, flag: "wx" });
-    return { declarationPath, launch: { engine: "grok", realmVolume: broker.realmVolume, bootstrap, declaration: declarationPath } };
+    return { declarationPath, launch: { engine: DAIMON_BROKER_ENGINE_ID, realmVolume: broker.realmVolume, bootstrap, declaration: declarationPath } };
 };

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

@@ -7,8 +7,6 @@ export declare const trainingBuildSchema: z.ZodObject<{
         "linux/amd64": "linux/amd64";
         "linux/arm64": "linux/arm64";
     }>;
-    paideia: z.ZodString;
-    bridge: z.ZodString;
     claude: z.ZodString;
     compiler: z.ZodOptional<z.ZodString>;
     grok: z.ZodOptional<z.ZodObject<{
@@ -41,9 +39,9 @@ export declare const trainingBrokerSchema: z.ZodObject<{
         "grok-build": "grok-build";
     }>;
     reasoningEffort: z.ZodEnum<{
-        high: "high";
-        medium: "medium";
         low: "low";
+        medium: "medium";
+        high: "high";
     }>;
     architecture: z.ZodEnum<{
         arm64: "arm64";
@@ -80,8 +78,6 @@ export declare const trainingPreparationSchema: z.ZodObject<{
                 "linux/amd64": "linux/amd64";
                 "linux/arm64": "linux/arm64";
             }>;
-            paideia: z.ZodString;
-            bridge: z.ZodString;
             claude: z.ZodString;
             compiler: z.ZodOptional<z.ZodString>;
             grok: z.ZodOptional<z.ZodObject<{
@@ -156,9 +152,9 @@ export declare const trainingPreparationSchema: z.ZodObject<{
             "grok-build": "grok-build";
         }>;
         reasoningEffort: z.ZodEnum<{
-            high: "high";
-            medium: "medium";
             low: "low";
+            medium: "medium";
+            high: "high";
         }>;
         architecture: z.ZodEnum<{
             arm64: "arm64";
@@ -191,7 +187,7 @@ export interface TrainingMappedPreparation {
     outputRoot: "/run/training/output";
     packagePaths: {
         spawnfile: string;
-        paideia: string;
+        training: string;
         bridge: string;
         nativeWorker: string;
         integration: string;

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

@@ -1,3 +1,4 @@
+import { DAIMON_BROKER_ENGINE_ID } from "../../../runtime/daimon/index.js";
 import path from "node:path";
 import { z } from "zod";
 import { trainingEvaluatorRoutesSchema, trainingEvaluatorSecretsSchema } from "../container/evaluators.js";
@@ -12,7 +13,7 @@ const destination = z.string().regex(/^\/run\/training\/inputs\/[A-Za-z0-9._/-]+
 export const trainingBuildSchema = z.object({
     recipe: z.literal("daimon-dspy.v1"), nativeImage: trainingImageSchema, pythonImage: trainingImageSchema,
     platform: z.enum(["linux/arm64", "linux/amd64"]),
-    paideia: local, bridge: local, claude: local, compiler: local.optional(),
+    claude: local, compiler: local.optional(),
     /**
      * Deprecated with `spawnfile.training-container.v3`: the image no longer
      * copies a Grok binary at all. Judges run the native parent's pinned
@@ -35,7 +36,7 @@ const bounds = DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds;
  */
 export const trainingBrokerSchema = z.object({
     maxRunRequests: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(1000),
-    engine: z.literal("grok"),
+    engine: z.literal(DAIMON_BROKER_ENGINE_ID),
     agentId: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u),
     model: z.enum(DAIMON_GROK_BROKER_MODELS),
     reasoningEffort: z.enum(DAIMON_GROK_BROKER_REASONING_EFFORTS),
@@ -102,7 +103,7 @@ const mappedSchema = z.object({
     version: z.literal("spawnfile.training-preparation.v1"), preparationDigest: sha, imageId: trainingImageSchema,
     bindings: z.array(z.object({ inputId: z.string().min(1), destination }).strict()).min(1).max(64),
     outputRoot: z.literal("/run/training/output"),
-    packagePaths: z.object({ spawnfile: containerPath, paideia: containerPath, bridge: containerPath,
+    packagePaths: z.object({ spawnfile: containerPath, training: containerPath, bridge: containerPath,
         nativeWorker: containerPath, integration: containerPath, bootstrap: containerPath }).strict(),
     integration: z.object({ settings: reference }).strict()
 }).strict().superRefine((value, context) => {

package/dist/compiler/training/preparation/image.js

@@ -29,7 +29,7 @@ export async function planTrainingImage(build, root, auth, ownRoot = packageRoot
     // and the declared native parent must name one rebuild (see daimonParent.ts).
     const daimonParent = await resolveTrainingDaimonParent(build, declarationPath);
     assertInputRoot(ownRoot, auth);
-    for (const source of [build.paideia, build.bridge, build.claude, build.integration.source, ...build.compiler ? [build.compiler] : [], ...build.bootstrap ? [build.bootstrap] : []])
+    for (const source of [build.claude, build.integration.source, ...build.compiler ? [build.compiler] : [], ...build.bootstrap ? [build.bootstrap] : []])
         assertInputRoot(resolve(source), auth);
     const assets = ownRoot === packageRoot ? trainingAssets : path.join(ownRoot, "runtime-images/training");
     assertInputRoot(assets, auth);
@@ -40,18 +40,16 @@ export async function planTrainingImage(build, root, auth, ownRoot = packageRoot
     const ownLock = path.extname(fileURLToPath(import.meta.url)) === ".ts" || ownRoot !== packageRoot
         ? path.join(ownRoot, "package-lock.json") : path.join(assets, "package-lock.json");
     const files = [
-        ...await packageFiles(resolve(build.paideia), "paideia", true),
         ...await packageFiles(ownRoot, "spawnfile", true, ownLock),
         ...await packageFiles(build.compiler ? resolve(build.compiler) : ownRoot, "compiler", true, build.compiler ? path.join(resolve(build.compiler), "package-lock.json") : ownLock),
         ...await packageFiles(resolve(build.claude), "claude", false),
-        ...await sealTree(resolve(build.bridge), "bridge", { ignoreDevelopment: true }),
         ...await sealTree(resolve(build.integration.source), "integration", { ignoreDevelopment: true }),
         ...build.bootstrap ? await sealTree(resolve(build.bootstrap), "bootstrap", { ignoreDevelopment: true }) : [],
         await sealFile(path.join(ownRoot, "runtimes.yaml"), "spawnfile/runtimes.yaml"),
         await sealFile(path.join(ownRoot, "moltnet-releases.json"), "spawnfile/moltnet-releases.json"),
         ...await Promise.all(["runtimes.yaml", "moltnet-releases.json"].map(name => sealFile(path.join(build.compiler ? resolve(build.compiler) : ownRoot, name), `compiler/${name}`)))
     ];
-    for (const required of [`integration/${build.integration.entry}`, "bridge/pyproject.toml", "bridge/requirements.lock", "bridge/paideia_dspy/__init__.py", "paideia/dist/src/cli/main.js", "spawnfile/dist/cli/index.js", "compiler/dist/cli/index.js"]) {
+    for (const required of [`integration/${build.integration.entry}`, "spawnfile/dist/training/dspy/pyproject.toml", "spawnfile/dist/training/dspy/requirements.lock", "spawnfile/dist/training/dspy/spawnfile_training_dspy/__init__.py", "spawnfile/dist/runtime/trainingCli.js", "spawnfile/dist/runtime/trainingSubjects.js", "spawnfile/dist/runtime/daimon/training/native/worker/cli.js", "spawnfile/dist/training/cli/index.js", "spawnfile/dist/cli/index.js", "compiler/dist/cli/index.js"]) {
         if (!files.some(file => file.destination === required))
             throw Error(`Training distribution is missing ${required}`);
     }

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

@@ -14,8 +14,8 @@ function mappedReceipt(digest, image, config) {
     return parseTrainingMappedPreparation({ version: "spawnfile.training-preparation.v1", preparationDigest: digest, imageId: image,
         bindings: config.inputs.map(input => ({ inputId: input.id, destination: input.destination })), outputRoot: "/run/training/output",
         packagePaths: { spawnfile: "build" in config.image && config.image.build.compiler
-                ? "/opt/training/compiler/dist/cli/index.js" : "/opt/training/spawnfile/dist/cli/index.js", paideia: "/opt/training/paideia", bridge: "/opt/training/paideia/bridges/dspy",
-            nativeWorker: "/opt/training/paideia/dist/src/adapters/daimon-native", integration: "/opt/training/integration", bootstrap: "/opt/training/bootstrap" }, integration: config.integration });
+                ? "/opt/training/compiler/dist/cli/index.js" : "/opt/training/spawnfile/dist/cli/index.js", training: "/opt/training/spawnfile/dist/training", bridge: "/opt/training/spawnfile/dist/training/dspy",
+            nativeWorker: "/opt/training/spawnfile/dist/runtime/daimon/training/native", integration: "/opt/training/integration", bootstrap: "/opt/training/bootstrap" }, integration: config.integration });
 }
 /** Reads only until the explicit dry-run boundary; preparation never executes project code. */
 export async function prepareTraining(options) {
@@ -217,7 +217,7 @@ export async function prepareTraining(options) {
             await writeFile(repairConfig, JSON.stringify(repairLaunch), { flag: "wx", mode: 0o600 });
         return { digest, image, configPath: repairConfig, preparationPath, repairPath: projected.repairPath, context,
             ...(options.execution ? { execution: mapTrainingExecution(options.execution, map) } : {}),
-            args: [...args, "--repair-measurements", "/run/training/inputs/repair-parent", "--repair-context", "/run/paideia/repair.json"] };
+            args: [...args, "--repair-measurements", "/run/training/inputs/repair-parent", "--repair-context", "/run/spawnfile-training/repair.json"] };
     }
     return { digest, image, configPath, preparationPath, context, args,
         ...(options.execution ? { execution: mapTrainingExecution(options.execution, map) } : {}) };

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

@@ -1,3 +1,4 @@
+import { hasLegacyTrainingDistribution } from '../../../shared/index.js';
 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) {
@@ -5,6 +6,9 @@ export function verifyTrainingCompatibility(witness, current, inputs, context) {
         JSON.stringify(context.agent) !== JSON.stringify(witness.context.agent))
         throw Error("Repair canonical agent changed");
     const old = witness.image.files, next = fileIdentity(current.files);
+    if (hasLegacyTrainingDistribution(witness.image)) {
+        throw Error("Repair references an external training distribution; re-prepare with Spawnfile before repairing measurements");
+    }
     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));
@@ -15,17 +19,24 @@ export function verifyTrainingCompatibility(witness, current, inputs, context) {
     const components = {};
     const compare = (name, previous, updated) => {
         if (previous !== updated)
-            throw Error(`Repair subject compatibility changed: ${name}`);
+            throw Error(`Repair subject compatibility changed: ${name}; re-prepare with Spawnfile before repairing measurements`);
         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/" }))
+    // The compiler closure excludes the training implementation so repair may update
+    // evaluator/fork transport while preserving subject and optimizer semantics below.
+    const compilerExclusions = ["compiler/dist/training/", "compiler/dist/runtime/trainingCli.js",
+        "compiler/dist/runtime/trainingCli.d.ts", "compiler/dist/runtime/trainingSubjects.js",
+        "compiler/dist/runtime/trainingSubjects.d.ts", "compiler/dist/runtime/daimon/training/", "compiler/dist/runtime/codex-exec/training/"];
+    compare("compiler", selection(old, "compiler/", compilerExclusions), selection(next, "compiler/", compilerExclusions));
+    for (const [name, prefix] of Object.entries({ integration: "integration/", "training-native": "spawnfile/dist/runtime/daimon/training/",
+        "training-trials": "spawnfile/dist/training/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 bridge = "spawnfile/dist/training/dspy/";
+    const excluded = ["spawnfile_training_dspy/checkpoint.py", "spawnfile_training_dspy/protocol.py", "README.md", "protocol.md", ".coverage", ".pytest_cache/", "coverage.json"]
+        .map(file => bridge + file);
+    compare("training-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))

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

@@ -33,8 +33,6 @@ export declare const witnessSchema: z.ZodObject<{
                     "linux/amd64": "linux/amd64";
                     "linux/arm64": "linux/arm64";
                 }>;
-                paideia: z.ZodString;
-                bridge: z.ZodString;
                 claude: z.ZodString;
                 compiler: z.ZodOptional<z.ZodString>;
                 grok: z.ZodOptional<z.ZodObject<{
@@ -109,9 +107,9 @@ export declare const witnessSchema: z.ZodObject<{
                 "grok-build": "grok-build";
             }>;
             reasoningEffort: z.ZodEnum<{
-                high: "high";
-                medium: "medium";
                 low: "low";
+                medium: "medium";
+                high: "high";
             }>;
             architecture: z.ZodEnum<{
                 arm64: "arm64";
@@ -267,9 +265,9 @@ export declare const witnessSchema: z.ZodObject<{
                                 id: z.ZodString;
                                 declaredBy: z.ZodString;
                                 section: z.ZodEnum<{
+                                    networks: "networks";
                                     memory: "memory";
                                     resources: "resources";
-                                    networks: "networks";
                                 }>;
                             }, z.core.$strict>>;
                         }, z.core.$strict>>;
@@ -290,9 +288,9 @@ export declare const witnessSchema: z.ZodObject<{
                                 id: z.ZodString;
                                 declaredBy: z.ZodString;
                                 section: z.ZodEnum<{
+                                    networks: "networks";
                                     memory: "memory";
                                     resources: "resources";
-                                    networks: "networks";
                                 }>;
                             }, z.core.$strict>>;
                         }, z.core.$strict>>;
@@ -313,9 +311,9 @@ export declare const witnessSchema: z.ZodObject<{
                                 id: z.ZodString;
                                 declaredBy: z.ZodString;
                                 section: z.ZodEnum<{
+                                    networks: "networks";
                                     memory: "memory";
                                     resources: "resources";
-                                    networks: "networks";
                                 }>;
                             }, z.core.$strict>>;
                         }, z.core.$strict>>;
@@ -364,8 +362,6 @@ export declare const witnessSchema: z.ZodObject<{
                 "linux/amd64": "linux/amd64";
                 "linux/arm64": "linux/arm64";
             }>;
-            paideia: z.ZodString;
-            bridge: z.ZodString;
             claude: z.ZodString;
             compiler: z.ZodOptional<z.ZodString>;
             grok: z.ZodOptional<z.ZodObject<{
@@ -419,8 +415,6 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                         "linux/amd64": "linux/amd64";
                         "linux/arm64": "linux/arm64";
                     }>;
-                    paideia: z.ZodString;
-                    bridge: z.ZodString;
                     claude: z.ZodString;
                     compiler: z.ZodOptional<z.ZodString>;
                     grok: z.ZodOptional<z.ZodObject<{
@@ -495,9 +489,9 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                     "grok-build": "grok-build";
                 }>;
                 reasoningEffort: z.ZodEnum<{
-                    high: "high";
-                    medium: "medium";
                     low: "low";
+                    medium: "medium";
+                    high: "high";
                 }>;
                 architecture: z.ZodEnum<{
                     arm64: "arm64";
@@ -653,9 +647,9 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                                     id: z.ZodString;
                                     declaredBy: z.ZodString;
                                     section: z.ZodEnum<{
+                                        networks: "networks";
                                         memory: "memory";
                                         resources: "resources";
-                                        networks: "networks";
                                     }>;
                                 }, z.core.$strict>>;
                             }, z.core.$strict>>;
@@ -676,9 +670,9 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                                     id: z.ZodString;
                                     declaredBy: z.ZodString;
                                     section: z.ZodEnum<{
+                                        networks: "networks";
                                         memory: "memory";
                                         resources: "resources";
-                                        networks: "networks";
                                     }>;
                                 }, z.core.$strict>>;
                             }, z.core.$strict>>;
@@ -699,9 +693,9 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                                     id: z.ZodString;
                                     declaredBy: z.ZodString;
                                     section: z.ZodEnum<{
+                                        networks: "networks";
                                         memory: "memory";
                                         resources: "resources";
-                                        networks: "networks";
                                     }>;
                                 }, z.core.$strict>>;
                             }, z.core.$strict>>;
@@ -750,8 +744,6 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
                     "linux/amd64": "linux/amd64";
                     "linux/arm64": "linux/arm64";
                 }>;
-                paideia: z.ZodString;
-                bridge: z.ZodString;
                 claude: z.ZodString;
                 compiler: z.ZodOptional<z.ZodString>;
                 grok: z.ZodOptional<z.ZodObject<{
@@ -779,7 +771,7 @@ export declare const witnessEnvelopeSchema: z.ZodObject<{
     digest: z.ZodString;
 }, z.core.$strict>;
 export declare const repairReceiptSchema: z.ZodObject<{
-    version: z.ZodLiteral<"paideia.measurement-repair.v1">;
+    version: z.ZodPreprocess<z.ZodLiteral<"spawnfile.training.measurement-repair.v1">>;
     parent: z.ZodObject<{
         root: z.ZodLiteral<"/run/training/inputs/repair-parent">;
         imageId: z.ZodString;
@@ -797,7 +789,7 @@ export declare const repairReceiptSchema: z.ZodObject<{
     current: z.ZodObject<{
         imageId: z.ZodString;
         canonicalSourceDigest: z.ZodString;
-        adapterId: z.ZodLiteral<"daimon-native">;
+        adapterId: z.ZodString;
     }, z.core.$strict>;
     compatibility: z.ZodObject<{
         version: z.ZodLiteral<"spawnfile.daimon-dspy-compatibility.v1">;
@@ -808,7 +800,7 @@ export declare const repairReceiptSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const repairEnvelopeSchema: z.ZodObject<{
     receipt: z.ZodObject<{
-        version: z.ZodLiteral<"paideia.measurement-repair.v1">;
+        version: z.ZodPreprocess<z.ZodLiteral<"spawnfile.training.measurement-repair.v1">>;
         parent: z.ZodObject<{
             root: z.ZodLiteral<"/run/training/inputs/repair-parent">;
             imageId: z.ZodString;
@@ -826,7 +818,7 @@ export declare const repairEnvelopeSchema: z.ZodObject<{
         current: z.ZodObject<{
             imageId: z.ZodString;
             canonicalSourceDigest: z.ZodString;
-            adapterId: z.ZodLiteral<"daimon-native">;
+            adapterId: z.ZodString;
         }, z.core.$strict>;
         compatibility: z.ZodObject<{
             version: z.ZodLiteral<"spawnfile.daimon-dspy-compatibility.v1">;

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

@@ -1,3 +1,4 @@
+import { compatibleWireLiteral } from '../../../shared/index.js';
 import path from "node:path";
 import { z } from "zod";
 import { trainingContextSchema } from "../contract.js";
@@ -21,12 +22,12 @@ export const witnessSchema = z.object({
 }).strict();
 export const witnessEnvelopeSchema = z.object({ manifest: witnessSchema, digest: sha }).strict();
 export const repairReceiptSchema = z.object({
-    version: z.literal("paideia.measurement-repair.v1"),
+    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.literal("daimon-native") }).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();

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

@@ -36,8 +36,6 @@ export declare function planMeasurementRepair(options: {
                         nativeImage: string;
                         pythonImage: string;
                         platform: "linux/amd64" | "linux/arm64";
-                        paideia: string;
-                        bridge: string;
                         claude: string;
                         integration: {
                             source: string;
@@ -97,7 +95,7 @@ export declare function planMeasurementRepair(options: {
                     engine: "grok";
                     agentId: string;
                     model: "grok-4.6" | "grok-4.5" | "grok-build";
-                    reasoningEffort: "high" | "medium" | "low";
+                    reasoningEffort: "low" | "medium" | "high";
                     architecture: "arm64" | "x64";
                     limits: {
                         maxRequests: number;
@@ -183,8 +181,6 @@ export declare function planMeasurementRepair(options: {
                     nativeImage: string;
                     pythonImage: string;
                     platform: "linux/amd64" | "linux/arm64";
-                    paideia: string;
-                    bridge: string;
                     claude: string;
                     integration: {
                         source: string;
@@ -270,7 +266,7 @@ export declare function planMeasurementRepair(options: {
                                     overrides: {
                                         id: string;
                                         declaredBy: string;
-                                        section: "memory" | "resources" | "networks";
+                                        section: "networks" | "memory" | "resources";
                                     }[];
                                 }[];
                             };
@@ -289,7 +285,7 @@ export declare function planMeasurementRepair(options: {
                                     overrides: {
                                         id: string;
                                         declaredBy: string;
-                                        section: "memory" | "resources" | "networks";
+                                        section: "networks" | "memory" | "resources";
                                     }[];
                                 }[];
                             } | null;
@@ -308,7 +304,7 @@ export declare function planMeasurementRepair(options: {
                                     overrides: {
                                         id: string;
                                         declaredBy: string;
-                                        section: "memory" | "resources" | "networks";
+                                        section: "networks" | "memory" | "resources";
                                     }[];
                                 }[];
                             };
@@ -354,7 +350,7 @@ export declare function planMeasurementRepair(options: {
     };
     files: import("../preparation/files.js").SealedFile[];
     command: {
-        schema: "paideia.command-checkpoint.v1";
+        schema: "spawnfile.training.command-checkpoint.v1";
         id: string;
         identity: string;
         lineage?: {

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

@@ -1,3 +1,5 @@
+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";
@@ -5,7 +7,7 @@ import { assertInputRoot, copySealed, exactPath, hashJson, sealFile, sealTree, w
 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(),
+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();
@@ -45,7 +47,7 @@ export async function planMeasurementRepair(options) {
     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 })) };
+    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) };
 }
@@ -53,11 +55,15 @@ export async function stageMeasurementRepair(plan, staging, image, canonicalSour
     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",
+    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: "daimon-native" }, compatibility });
+        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))

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

@@ -22,8 +22,6 @@ export declare function readTrainingWitness(file: string): Promise<{
                     nativeImage: string;
                     pythonImage: string;
                     platform: "linux/amd64" | "linux/arm64";
-                    paideia: string;
-                    bridge: string;
                     claude: string;
                     integration: {
                         source: string;
@@ -83,7 +81,7 @@ export declare function readTrainingWitness(file: string): Promise<{
                 engine: "grok";
                 agentId: string;
                 model: "grok-4.6" | "grok-4.5" | "grok-build";
-                reasoningEffort: "high" | "medium" | "low";
+                reasoningEffort: "low" | "medium" | "high";
                 architecture: "arm64" | "x64";
                 limits: {
                     maxRequests: number;
@@ -169,8 +167,6 @@ export declare function readTrainingWitness(file: string): Promise<{
                 nativeImage: string;
                 pythonImage: string;
                 platform: "linux/amd64" | "linux/arm64";
-                paideia: string;
-                bridge: string;
                 claude: string;
                 integration: {
                     source: string;
@@ -256,7 +252,7 @@ export declare function readTrainingWitness(file: string): Promise<{
                                 overrides: {
                                     id: string;
                                     declaredBy: string;
-                                    section: "memory" | "resources" | "networks";
+                                    section: "networks" | "memory" | "resources";
                                 }[];
                             }[];
                         };
@@ -275,7 +271,7 @@ export declare function readTrainingWitness(file: string): Promise<{
                                 overrides: {
                                     id: string;
                                     declaredBy: string;
-                                    section: "memory" | "resources" | "networks";
+                                    section: "networks" | "memory" | "resources";
                                 }[];
                             }[];
                         } | null;
@@ -294,7 +290,7 @@ export declare function readTrainingWitness(file: string): Promise<{
                                 overrides: {
                                     id: string;
                                     declaredBy: string;
-                                    section: "memory" | "resources" | "networks";
+                                    section: "networks" | "memory" | "resources";
                                 }[];
                             }[];
                         };

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

@@ -1,13 +1,27 @@
+import { hasLegacyTrainingDistribution } from '../../../shared/index.js';
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { z } from "zod";
 import { trainingExecutionIdentity } from "../execution.js";
 import { copySealed, exactPath, fileIdentity, hashJson, sealTree } from "../preparation/files.js";
-import { witnessEnvelopeSchema } from "./contract.js";
+import { sha, witnessEnvelopeSchema } from "./contract.js";
+// Validate every property inspected before the full current-schema parse. Legacy
+// builds cannot use that current schema, but malformed JSON must never bypass it
+// through unchecked property/method access in the migration diagnostic.
+const witnessHeaderSchema = z.object({ manifest: z.unknown(), digest: sha }).strict();
+const legacyImageSchema = z.object({ image: z.object({
+        build: z.record(z.string(), z.unknown()),
+        files: z.array(z.object({ destination: z.string() }).passthrough())
+    }).passthrough() }).passthrough();
 export async function readTrainingWitness(file) {
     const canonical = await exactPath(file), bytes = await readFile(canonical, "utf8");
     if (Buffer.byteLength(bytes) > 8 * 1024 * 1024)
         throw Error("Training witness exceeds 8 MiB");
-    const raw = JSON.parse(bytes);
+    const raw = witnessHeaderSchema.parse(JSON.parse(bytes));
+    const legacy = legacyImageSchema.safeParse(raw.manifest);
+    if (legacy.success && hasLegacyTrainingDistribution(legacy.data.image)) {
+        throw Error("Repair witness references an external training distribution; re-prepare with Spawnfile before repairing measurements");
+    }
     if (hashJson(raw.manifest) !== raw.digest)
         throw Error("Training witness digest mismatch");
     const parsed = witnessEnvelopeSchema.parse(raw), witness = parsed.manifest;