spawnfile 0.1.14 → 0.1.18

package/dist/compiler/training/context.js

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { SpawnfileError } from "../../shared/index.js";
+import { getManifestPath } from "../../filesystem/index.js";
+import { buildCompilePlan } from "../buildCompilePlan.js";
+import { stableStringify } from "../helpers.js";
+import { resolveEffectiveModelTarget } from "../modelEnv.js";
+import { pinWorkspaceBundle } from "../workspaceBundleResolve.js";
+import { selectTrainingAgent } from "./selection.js";
+import { TRAINING_CONTEXT_VERSION, trainingContextSchema } from "./contract.js";
+const sha256 = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
+const invalid = (message) => { throw new SpawnfileError("validation_error", message); };
+const inside = (root, file) => {
+    const relative = path.relative(root, file);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+/** Internal host-side resolution shared by context capture and subject admission. */
+export const resolveTrainingContextGraph = async (inputPath, selector) => {
+    const plan = await buildCompilePlan(await realpath(getManifestPath(inputPath)));
+    const agents = plan.nodes.filter((node) => node.kind === "agent");
+    return { plan, selected: selectTrainingAgent(agents, selector) };
+};
+/** Resolves the complete project, preserving inherited selection and source provenance. */
+export const createTrainingContext = async (inputPath, options) => {
+    const { plan, selected } = await resolveTrainingContextGraph(inputPath, options.agent);
+    const agent = selected.value;
+    const manifest = await realpath(plan.root);
+    const root = path.dirname(manifest);
+    const pins = new Map();
+    const pin = async (source, expectedContent) => {
+        const sourcePath = path.resolve(source);
+        if (!inside(root, sourcePath) || !inside(root, await realpath(sourcePath))) {
+            invalid("Training context v1 requires source files inside the canonical project root");
+        }
+        const info = await stat(sourcePath);
+        if (!info.isFile() || info.size > 16 * 1024 * 1024)
+            invalid("Training source must be a regular file no larger than 16 MiB");
+        const bytes = await readFile(sourcePath);
+        if (expectedContent !== undefined && bytes.toString("utf8") !== expectedContent) {
+            invalid("Training source changed during canonical graph resolution");
+        }
+        const next = { sourcePath, destinationPath: path.relative(root, sourcePath).split(path.sep).join("/"), sha256: sha256(bytes) };
+        const previous = pins.get(sourcePath);
+        if (previous && previous.sha256 !== next.sha256)
+            invalid("Training source changed while its context was captured");
+        pins.set(sourcePath, next);
+        return next;
+    };
+    await pin(manifest);
+    // Manifests for inline nodes live at sourcePath; their synthetic node source is not a file.
+    for (const node of plan.nodes) {
+        await pin(node.value.kind === "agent" ? node.value.sourcePath ?? node.value.source : node.value.source);
+        for (const document of node.value.docs)
+            await pin(document.sourcePath, document.content);
+        const skills = node.value.kind === "agent" ? node.value.skills : node.value.shared.skills;
+        for (const skill of skills)
+            await pin(skill.sourcePath, skill.content);
+    }
+    const documents = await Promise.all(agent.docs.map(async (document) => ({
+        ...await pin(document.sourcePath, document.content), role: document.role
+    })));
+    const skills = await Promise.all(agent.skills.map(async (skill) => ({
+        ...await pin(skill.sourcePath, skill.content), name: skill.name, ref: skill.ref, requiresMcp: skill.requiresMcp
+    })));
+    // A manifest can change after graph resolution but before its first pin. Re-resolve
+    // through the compiler owner, then seal all captured bytes against that graph.
+    if (stableStringify(plan) !== stableStringify(await buildCompilePlan(manifest))) {
+        invalid("Training source changed between canonical resolution and provenance capture");
+    }
+    for (const source of [...pins.keys()])
+        await pin(source);
+    const sources = [...pins.values()].sort((left, right) => left.destinationPath < right.destinationPath ? -1 : left.destinationPath > right.destinationPath ? 1 : 0);
+    const declaredPrimary = agent.execution?.model?.primary;
+    const primary = declaredPrimary ? resolveEffectiveModelTarget(declaredPrimary, agent.execution) : undefined;
+    return trainingContextSchema.parse({
+        version: TRAINING_CONTEXT_VERSION,
+        producer: { package: "spawnfile", version: options.packageVersion },
+        project: { root, manifest, sourceDigest: sha256(JSON.stringify(sources.map(({ destinationPath, sha256: hash }) => ({ destinationPath, sha256: hash })))) },
+        agent: {
+            id: selected.id, name: agent.name, source: path.resolve(agent.sourcePath ?? agent.source), runtime: agent.runtime.name,
+            engine: typeof agent.runtime.options.engine === "string" ? agent.runtime.options.engine : null,
+            model: primary ? { provider: primary.provider, name: primary.name, authMethod: primary.auth.method } : null
+        },
+        sources, documents, skills,
+        resources: await Promise.all((agent.workspaceResources ?? []).map(async (resource) => ({
+            id: resource.id, kind: resource.kind, mount: resource.mount, mode: resource.mode, sharing: resource.sharing,
+            definitionDigest: sha256(stableStringify(resource)),
+            pin: resource.kind === "bundle" ? await pinWorkspaceBundle(resource) : resource.kind === "git" ? resource.ref ?? null : null
+        }))),
+        requirements: { nativeCompilation: true, isolatedPreparation: true }
+    });
+};

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

@@ -0,0 +1,144 @@
+import { z } from "zod";
+export declare const TRAINING_CONTEXT_VERSION: "spawnfile.training-context.v1";
+export declare const TRAINING_EXECUTION_CAPABILITY_LABEL = "com.spawnfile.training.execution";
+export declare const TRAINING_EXECUTION_VERSION = "spawnfile.training-execution.v1";
+export declare const trainingSourceSchema: z.ZodObject<{
+    sourcePath: z.ZodString;
+    destinationPath: z.ZodString;
+    sha256: z.ZodString;
+}, z.core.$strict>;
+/** Trusted compiler metadata only; this is neither a prompt nor permission to launch. */
+export declare const trainingContextSchema: z.ZodObject<{
+    version: z.ZodLiteral<"spawnfile.training-context.v1">;
+    producer: z.ZodObject<{
+        package: z.ZodLiteral<"spawnfile">;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    project: z.ZodObject<{
+        root: z.ZodString;
+        manifest: z.ZodString;
+        sourceDigest: z.ZodString;
+    }, z.core.$strict>;
+    agent: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodString;
+        runtime: z.ZodString;
+        engine: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+            authMethod: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    sources: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    documents: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+        role: z.ZodString;
+    }, z.core.$strict>>;
+    skills: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+        name: z.ZodString;
+        ref: z.ZodString;
+        requiresMcp: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            volume: "volume";
+            git: "git";
+            bundle: "bundle";
+        }>;
+        mount: z.ZodString;
+        mode: z.ZodEnum<{
+            readonly: "readonly";
+            mutable: "mutable";
+        }>;
+        sharing: z.ZodEnum<{
+            per_agent: "per_agent";
+            team: "team";
+        }>;
+        definitionDigest: z.ZodString;
+        pin: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    requirements: z.ZodObject<{
+        nativeCompilation: z.ZodLiteral<true>;
+        isolatedPreparation: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TrainingContext = z.infer<typeof trainingContextSchema>;
+export type TrainingSource = z.infer<typeof trainingSourceSchema>;
+export declare const trainingContextJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    version: z.ZodLiteral<"spawnfile.training-context.v1">;
+    producer: z.ZodObject<{
+        package: z.ZodLiteral<"spawnfile">;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    project: z.ZodObject<{
+        root: z.ZodString;
+        manifest: z.ZodString;
+        sourceDigest: z.ZodString;
+    }, z.core.$strict>;
+    agent: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodString;
+        runtime: z.ZodString;
+        engine: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+            authMethod: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    sources: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    documents: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+        role: z.ZodString;
+    }, z.core.$strict>>;
+    skills: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        destinationPath: z.ZodString;
+        sha256: z.ZodString;
+        name: z.ZodString;
+        ref: z.ZodString;
+        requiresMcp: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            volume: "volume";
+            git: "git";
+            bundle: "bundle";
+        }>;
+        mount: z.ZodString;
+        mode: z.ZodEnum<{
+            readonly: "readonly";
+            mutable: "mutable";
+        }>;
+        sharing: z.ZodEnum<{
+            per_agent: "per_agent";
+            team: "team";
+        }>;
+        definitionDigest: z.ZodString;
+        pin: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    requirements: z.ZodObject<{
+        nativeCompilation: z.ZodLiteral<true>;
+        isolatedPreparation: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/compiler/training/contract.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export const TRAINING_CONTEXT_VERSION = "spawnfile.training-context.v1";
+export const TRAINING_EXECUTION_CAPABILITY_LABEL = "com.spawnfile.training.execution";
+export const TRAINING_EXECUTION_VERSION = "spawnfile.training-execution.v1";
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const absolutePath = z.string().min(1).regex(/^(?:\/|[A-Za-z]:[\\/])/u);
+const relativePath = z.string().min(1).regex(/^(?!\/)(?!.*(?:^|\/)\.\.(?:\/|$))[^\\]+$/u);
+const text = z.string().min(1);
+export const trainingSourceSchema = z.object({
+    sourcePath: absolutePath,
+    destinationPath: relativePath,
+    sha256: digest
+}).strict();
+/** Trusted compiler metadata only; this is neither a prompt nor permission to launch. */
+export const trainingContextSchema = z.object({
+    version: z.literal(TRAINING_CONTEXT_VERSION),
+    producer: z.object({ package: z.literal("spawnfile"), version: text }).strict(),
+    project: z.object({ root: absolutePath, manifest: absolutePath, sourceDigest: digest }).strict(),
+    agent: z.object({
+        id: text, name: text, source: absolutePath, runtime: text,
+        engine: text.nullable(),
+        model: z.object({ provider: text, name: text, authMethod: text }).strict().nullable()
+    }).strict(),
+    sources: z.array(trainingSourceSchema).min(1).max(10_000),
+    documents: z.array(trainingSourceSchema.extend({ role: text }).strict()).max(128),
+    skills: z.array(trainingSourceSchema.extend({
+        name: text, ref: text, requiresMcp: z.array(text)
+    }).strict()).max(1_000),
+    resources: z.array(z.object({
+        id: text, kind: z.enum(["bundle", "git", "volume"]), mount: text,
+        mode: z.enum(["mutable", "readonly"]), sharing: z.enum(["per_agent", "team"]),
+        definitionDigest: digest, pin: text.nullable()
+    }).strict()).max(1_000),
+    requirements: z.object({ nativeCompilation: z.literal(true), isolatedPreparation: z.literal(true) }).strict()
+}).strict();
+export const trainingContextJsonSchema = z.toJSONSchema(trainingContextSchema);

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

@@ -0,0 +1,417 @@
+import { z } from "zod";
+import { type TrainingPlan } from "./plan/contract.js";
+import type { LoadedTrainingProject } from "./plan/types.js";
+export declare const TRAINING_EXECUTION_FILE = "/run/paideia/execution.json";
+export { TRAINING_EXECUTION_CAPABILITY_LABEL, TRAINING_EXECUTION_VERSION } from "./contract.js";
+export declare const trainingExecutionSchema: z.ZodObject<{
+    version: z.ZodLiteral<"spawnfile.training-execution.v1">;
+    authoring: z.ZodObject<{
+        version: z.ZodLiteral<"spawnfile.training-plan.v1">;
+        producer: z.ZodObject<{
+            package: z.ZodLiteral<"spawnfile">;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        project: z.ZodObject<{
+            root: z.ZodString;
+            manifest: z.ZodString;
+        }, z.core.$strict>;
+        agent: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        deadlines: z.ZodOptional<z.ZodObject<{
+            experiment_ms: z.ZodNumber;
+            trial_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        preparation: z.ZodOptional<z.ZodObject<{
+            hook: z.ZodString;
+            history: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        record: z.ZodNullable<z.ZodObject<{
+            keep: z.ZodNullable<z.ZodString>;
+            volumes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                declaredBy: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        optimizer: z.ZodNullable<z.ZodObject<{
+            method: z.ZodString;
+            model: z.ZodString;
+            variants: z.ZodNumber;
+            keep: z.ZodNumber;
+            budget: z.ZodObject<{
+                rounds: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        graders: z.ZodArray<z.ZodObject<{
+            sourcePath: z.ZodString;
+            path: z.ZodString;
+            name: z.ZodString;
+            declaredBy: z.ZodString;
+        }, z.core.$strict>>;
+        targets: z.ZodArray<z.ZodObject<{
+            declaredBy: z.ZodString;
+            grader: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                sourcePath: z.ZodString;
+                path: z.ZodString;
+                consumers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            datasets: z.ZodObject<{
+                train: z.ZodObject<{
+                    sourcePath: z.ZodString;
+                    path: z.ZodString;
+                    examples: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        at: z.ZodISODateTime;
+                        wake: z.ZodObject<{
+                            surface: z.ZodLiteral<"moltnet">;
+                            room: z.ZodString;
+                            from: z.ZodString;
+                            text: z.ZodString;
+                        }, z.core.$strict>;
+                        overrides: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            declaredBy: z.ZodString;
+                            section: z.ZodEnum<{
+                                memory: "memory";
+                                resources: "resources";
+                                networks: "networks";
+                            }>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                validation: z.ZodNullable<z.ZodObject<{
+                    sourcePath: z.ZodString;
+                    path: z.ZodString;
+                    examples: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        at: z.ZodISODateTime;
+                        wake: z.ZodObject<{
+                            surface: z.ZodLiteral<"moltnet">;
+                            room: z.ZodString;
+                            from: z.ZodString;
+                            text: z.ZodString;
+                        }, z.core.$strict>;
+                        overrides: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            declaredBy: z.ZodString;
+                            section: z.ZodEnum<{
+                                memory: "memory";
+                                resources: "resources";
+                                networks: "networks";
+                            }>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                test: z.ZodObject<{
+                    sourcePath: z.ZodString;
+                    path: z.ZodString;
+                    examples: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        at: z.ZodISODateTime;
+                        wake: z.ZodObject<{
+                            surface: z.ZodLiteral<"moltnet">;
+                            room: z.ZodString;
+                            from: z.ZodString;
+                            text: z.ZodString;
+                        }, z.core.$strict>;
+                        overrides: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            declaredBy: z.ZodString;
+                            section: z.ZodEnum<{
+                                memory: "memory";
+                                resources: "resources";
+                                networks: "networks";
+                            }>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    datasetPins: z.ZodArray<z.ZodObject<{
+        sourcePath: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>;
+    optimizer: z.ZodObject<{
+        method: z.ZodString;
+        model: z.ZodString;
+        variants: z.ZodNumber;
+        keep: z.ZodNumber;
+        budget: z.ZodObject<{
+            rounds: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    args: z.ZodArray<z.ZodString>;
+    output: z.ZodString;
+}, z.core.$strict>;
+export type TrainingExecution = z.infer<typeof trainingExecutionSchema>;
+export interface LowerTrainingExecutionOptions {
+    project: LoadedTrainingProject;
+    plan: TrainingPlan;
+    args: readonly string[];
+    trainingConfig?: string;
+    trainingImage?: string;
+}
+/** Resolve local declaration and authoring defaults; no writes, auth reads or execution. */
+export declare const lowerTrainingExecution: (options: LowerTrainingExecutionOptions) => Promise<{
+    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;
+    };
+    trainingConfig: string;
+    trainingImage: string | undefined;
+    declaration: {
+        version: "spawnfile.training-container.v1" | "spawnfile.training-container.v3" | "spawnfile.training-container.v4";
+        slots: number;
+        dockerContext: string;
+        inputs: {
+            source: string;
+            destination: string;
+        }[];
+        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?: {
+            engine: "grok";
+            realmVolume: string;
+            bootstrap: string;
+            declaration: string;
+        } | undefined;
+    } | {
+        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;
+    };
+}>;
+/** Allocation is separate so dry-run never creates a directory, and aliases fail before writes. */
+export declare const allocateTrainingOutputParent: (output: string) => Promise<void>;
+/** Preserve identities and all dataset roles while projecting only filesystem addresses. */
+export declare const mapTrainingExecution: (execution: TrainingExecution, map: (file: string) => string) => TrainingExecution;
+/** Resume changes position/presence of --resume, not the experiment's effective inputs. */
+export declare const trainingExecutionIdentity: (execution: TrainingExecution) => unknown;