spawnfile 0.1.33 → 0.1.34

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

@@ -1,348 +0,0 @@
-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";
-export declare function readTrainingWitness(file: string): Promise<{
-    path: string;
-    manifest: {
-        schema: "spawnfile.training-legacy-witness.v1" | "spawnfile.training-witness.v1";
-        parentImage: string;
-        parentPreparationDigest: string;
-        imagePlanDigest: string;
-        config: {
-            version: "spawnfile.training-container.v3" | "spawnfile.training-container.v4" | "spawnfile.training-container.v2";
-            slots: number;
-            dockerContext: string;
-            image: {
-                ref: string;
-            } | {
-                build: {
-                    recipe: "daimon-dspy.v1";
-                    nativeImage: string;
-                    pythonImage: string;
-                    platform: "linux/amd64" | "linux/arm64";
-                    claude: string;
-                    integration: {
-                        source: string;
-                        entry: string;
-                        execution?: "spawnfile.training-execution.v1" | undefined;
-                    };
-                    compiler?: string | undefined;
-                    grok?: {
-                        source: string;
-                        sha256: string;
-                    } | undefined;
-                    bootstrap?: string | undefined;
-                };
-            };
-            integration: {
-                settings: {
-                    input: string;
-                    path: string;
-                };
-            };
-            inputs: {
-                id: string;
-                source: string;
-                destination: string;
-                include?: string[] | undefined;
-                git?: {
-                    revision: string;
-                    overlays: {
-                        source: string;
-                        path: string;
-                        sha256: string;
-                    }[];
-                } | undefined;
-            }[];
-            output: {
-                source: string;
-                destination: "/run/training/output";
-            };
-            auth: {
-                source: string;
-                provider: "codex" | "claude";
-            }[];
-            evaluatorRoutes?: {
-                purpose: "decisions" | "extraction" | "proposals";
-                provider: "codex-subscription" | "typesafe";
-                model: string;
-                maxRequests: number;
-                maxSpendUsd?: number | undefined;
-            }[] | undefined;
-            evaluatorSecrets?: {
-                provider: "typesafe";
-                source: string;
-            }[] | undefined;
-            subjectIsolation?: "codex-native-sandbox" | undefined;
-            broker?: {
-                maxRunRequests: number;
-                engine: "grok";
-                agentId: string;
-                model: "grok-4.6" | "grok-4.5" | "grok-build";
-                reasoningEffort: "low" | "medium" | "high";
-                architecture: "arm64" | "x64";
-                limits: {
-                    maxRequests: number;
-                    maxTokens: number;
-                    timeoutMs: number;
-                };
-                realmVolume: string;
-                bootstrap: string;
-                unenforcedBindPolicy?: "refuse" | "profile-only" | undefined;
-            } | undefined;
-        };
-        context: {
-            version: "spawnfile.training-context.v1";
-            producer: {
-                package: "spawnfile";
-                version: string;
-            };
-            project: {
-                root: string;
-                manifest: string;
-                sourceDigest: string;
-            };
-            agent: {
-                id: string;
-                name: string;
-                source: string;
-                runtime: string;
-                engine: string | null;
-                model: {
-                    provider: string;
-                    name: string;
-                    authMethod: string;
-                } | null;
-            };
-            sources: {
-                sourcePath: string;
-                destinationPath: string;
-                sha256: string;
-            }[];
-            documents: {
-                sourcePath: string;
-                destinationPath: string;
-                sha256: string;
-                role: string;
-            }[];
-            skills: {
-                sourcePath: string;
-                destinationPath: string;
-                sha256: string;
-                name: string;
-                ref: string;
-                requiresMcp: string[];
-            }[];
-            resources: {
-                id: string;
-                kind: "volume" | "git" | "bundle";
-                mount: string;
-                mode: "readonly" | "mutable";
-                sharing: "per_agent" | "team";
-                definitionDigest: string;
-                pin: string | null;
-            }[];
-            requirements: {
-                nativeCompilation: true;
-                isolatedPreparation: true;
-            };
-        };
-        command: {
-            args: string[];
-            env?: Record<string, string> | undefined;
-        };
-        inputs: {
-            id: string;
-            source: string;
-            destination: string;
-            digest: string;
-            staged: string;
-            snapshotDigest: string | null;
-        }[];
-        image: {
-            build: {
-                recipe: "daimon-dspy.v1";
-                nativeImage: string;
-                pythonImage: string;
-                platform: "linux/amd64" | "linux/arm64";
-                claude: string;
-                integration: {
-                    source: string;
-                    entry: string;
-                    execution?: "spawnfile.training-execution.v1" | undefined;
-                };
-                compiler?: string | undefined;
-                grok?: {
-                    source: string;
-                    sha256: string;
-                } | undefined;
-                bootstrap?: string | undefined;
-            };
-            dockerfile: string;
-            entry: string;
-            brokerEntry: string;
-            files: {
-                destination: string;
-                sha256: string;
-                mode: number;
-                size: number;
-            }[];
-        };
-        execution?: {
-            version: "spawnfile.training-execution.v1";
-            authoring: {
-                version: "spawnfile.training-plan.v1";
-                producer: {
-                    package: "spawnfile";
-                    version: string;
-                };
-                project: {
-                    root: string;
-                    manifest: string;
-                };
-                agent: {
-                    id: string;
-                    name: string;
-                };
-                record: {
-                    keep: string | null;
-                    volumes: {
-                        id: string;
-                        declaredBy: string;
-                    }[];
-                } | null;
-                optimizer: {
-                    method: string;
-                    model: string;
-                    variants: number;
-                    keep: number;
-                    budget: {
-                        rounds: number;
-                    };
-                } | null;
-                graders: {
-                    sourcePath: string;
-                    path: string;
-                    name: string;
-                    declaredBy: string;
-                }[];
-                targets: {
-                    declaredBy: string;
-                    grader: string;
-                    files: {
-                        sourcePath: string;
-                        path: string;
-                        consumers: string[];
-                    }[];
-                    datasets: {
-                        train: {
-                            sourcePath: string;
-                            path: string;
-                            examples: {
-                                id: string;
-                                at: string;
-                                wake: {
-                                    surface: "moltnet";
-                                    room: string;
-                                    from: string;
-                                    text: string;
-                                };
-                                overrides: {
-                                    id: string;
-                                    declaredBy: string;
-                                    section: "networks" | "memory" | "resources";
-                                }[];
-                            }[];
-                        };
-                        validation: {
-                            sourcePath: string;
-                            path: string;
-                            examples: {
-                                id: string;
-                                at: string;
-                                wake: {
-                                    surface: "moltnet";
-                                    room: string;
-                                    from: string;
-                                    text: string;
-                                };
-                                overrides: {
-                                    id: string;
-                                    declaredBy: string;
-                                    section: "networks" | "memory" | "resources";
-                                }[];
-                            }[];
-                        } | null;
-                        test: {
-                            sourcePath: string;
-                            path: string;
-                            examples: {
-                                id: string;
-                                at: string;
-                                wake: {
-                                    surface: "moltnet";
-                                    room: string;
-                                    from: string;
-                                    text: string;
-                                };
-                                overrides: {
-                                    id: string;
-                                    declaredBy: string;
-                                    section: "networks" | "memory" | "resources";
-                                }[];
-                            }[];
-                        };
-                    };
-                }[];
-                deadlines?: {
-                    experiment_ms: number;
-                    trial_ms?: number | undefined;
-                } | undefined;
-                preparation?: {
-                    hook: string;
-                    history?: string | undefined;
-                } | undefined;
-            };
-            datasetPins: {
-                sourcePath: string;
-                sha256: string;
-            }[];
-            optimizer: {
-                method: string;
-                model: string;
-                variants: number;
-                keep: number;
-                budget: {
-                    rounds: number;
-                };
-            };
-            args: string[];
-            output: string;
-        } | undefined;
-        repair?: {
-            witness: string;
-            parent: string;
-        } | undefined;
-    };
-    digest: string;
-}>;
-/** Future repairs need sealed original bytes, not a mutable checkout or caller assertion. */
-export declare function writeTrainingWitness(options: {
-    directory: string;
-    digest: string;
-    image: string;
-    config: TrainingPreparationConfig;
-    context: TrainingContext;
-    args: readonly string[];
-    execution?: TrainingExecution;
-    inputs: PlannedInput[];
-    staged: string[];
-    snapshots: (string | null)[];
-    plan: TrainingImagePlan;
-    repair?: {
-        witness: string;
-        parent: string;
-    };
-}): Promise<void>;

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

@@ -1,62 +0,0 @@
-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 { 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 = 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;
-    const files = await sealTree(path.join(path.dirname(canonical), "image-files"), "");
-    const sorted = (value) => [...value].sort((a, b) => a.destination.localeCompare(b.destination));
-    if (hashJson(sorted(fileIdentity(files))) !== hashJson(sorted(witness.image.files)))
-        throw Error("Training witness image bytes changed");
-    const { recipe, nativeImage, pythonImage, platform } = witness.image.build;
-    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");
-    // 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,
-        ...(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 };
-}
-/** Future repairs need sealed original bytes, not a mutable checkout or caller assertion. */
-export async function writeTrainingWitness(options) {
-    const directory = path.join(options.directory, "witness");
-    await mkdir(directory, { mode: 0o700 });
-    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,
-            digest: input.digest, staged: options.staged[index], snapshotDigest: options.snapshots[index] })),
-        image: { build: options.plan.build, files: fileIdentity(options.plan.files), dockerfile: options.plan.dockerfile,
-            entry: options.plan.entry, brokerEntry: options.plan.brokerEntry } };
-    await writeFile(path.join(directory, "manifest.json"), JSON.stringify({ manifest, digest: hashJson(manifest) }), { flag: "wx", mode: 0o400 });
-}

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

@@ -1,26 +0,0 @@
-import { DAIMON_BROKER_ENGINE_ID, DAIMON_PORTABLE_ENGINE_ID } from "../../runtime/daimon/index.js";
-/** The slice of a leased broker section the declaration must agree with. */
-export interface TrainingSubjectDeclaredBroker {
-    limits: {
-        maxRequests: number;
-        maxTokens: number;
-        timeoutMs: number;
-    };
-    workerConfigVariant: string;
-}
-/**
- * Declaration-level policy a training subject must already satisfy in its
- * resolved Spawnfile (inheritance included), checked before any compiler or
- * subject runs.
- *
- * - Codex: the Daimon declaration states `codex_policy: workspace-no-network`
- *   and carries neither a broker slot nor `turn_limits`.
- * - Grok: the declaration states all three `turn_limits`, each equal to the
- *   leased broker's registration limits, because a wake may only lower a
- *   registered limit and a trial must not run on a silently different budget;
- *   and the slot is the `clocked` worker variant, the only one that can hold a
- *   moment's shell clock.
- *
- * Any other runtime or engine is refused. Returns the engine it checked.
- */
-export declare const assertTrainingSubjectDeclaration: (projectRoot: string, agentId: string, broker?: TrainingSubjectDeclaredBroker) => Promise<typeof DAIMON_PORTABLE_ENGINE_ID | typeof DAIMON_BROKER_ENGINE_ID>;

package/dist/compiler/training/subjectDeclaration.js

@@ -1,54 +0,0 @@
-import { DAIMON_BROKER_ENGINE_ID, DAIMON_PORTABLE_ENGINE_ID, getDaimonEngineDescriptor } from "../../runtime/daimon/index.js";
-import { SpawnfileError } from "../../shared/index.js";
-import { resolveDaimonEngine } from "../../runtime/daimon/config.js";
-import { resolveDaimonGrokTurnLimits } from "../../runtime/daimon/grokTurnLimits.js";
-import { loadTrainingProject } from "./plan/load.js";
-import { selectTrainingAgent } from "./selection.js";
-const refuse = (message) => { throw new SpawnfileError("validation_error", message); };
-const LIMITS = [["maxRequests", "max_requests"], ["maxTokens", "max_tokens"], ["timeoutMs", "timeout_ms"]];
-/**
- * Declaration-level policy a training subject must already satisfy in its
- * resolved Spawnfile (inheritance included), checked before any compiler or
- * subject runs.
- *
- * - Codex: the Daimon declaration states `codex_policy: workspace-no-network`
- *   and carries neither a broker slot nor `turn_limits`.
- * - Grok: the declaration states all three `turn_limits`, each equal to the
- *   leased broker's registration limits, because a wake may only lower a
- *   registered limit and a trial must not run on a silently different budget;
- *   and the slot is the `clocked` worker variant, the only one that can hold a
- *   moment's shell clock.
- *
- * Any other runtime or engine is refused. Returns the engine it checked.
- */
-export const assertTrainingSubjectDeclaration = async (projectRoot, agentId, broker) => {
-    const project = await loadTrainingProject(projectRoot);
-    const agents = project.compilePlan.nodes.filter((node) => node.value.kind === "agent");
-    const node = selectTrainingAgent(agents, agentId).value;
-    if (node.runtime.name !== "daimon")
-        return refuse(`Training subject ${agentId} must declare runtime daimon, not ${node.runtime.name}`);
-    const engine = resolveDaimonEngine(node);
-    const declared = resolveDaimonGrokTurnLimits(node.runtime.options.turn_limits);
-    const subject = getDaimonEngineDescriptor(engine)?.training.subject;
-    if (subject?.supported && subject.isolation === "native-sandbox" && engine === DAIMON_PORTABLE_ENGINE_ID) {
-        if (node.runtime.options.codex_policy !== "workspace-no-network") {
-            refuse(`Codex training subject ${agentId} requires explicit codex_policy: workspace-no-network on its Daimon declaration`);
-        }
-        if (broker !== undefined || declared !== undefined)
-            refuse(`Codex training subject ${agentId} takes no broker slot and no turn_limits`);
-        return engine;
-    }
-    if (!subject?.supported || subject.isolation !== "broker-worker" || engine !== DAIMON_BROKER_ENGINE_ID)
-        return refuse(`Training subject ${agentId} uses Daimon engine ${engine}; only codex and grok subjects train`);
-    if (!broker)
-        return refuse(`Grok training subject ${agentId} requires its leased broker slot`);
-    for (const [native, authored] of LIMITS) {
-        if (declared?.[native] !== broker.limits[native]) {
-            refuse(`Grok training subject ${agentId} turn_limits.${authored} (${String(declared?.[native] ?? "undeclared")}) differs from the broker limit ${broker.limits[native]}`);
-        }
-    }
-    if (broker.workerConfigVariant !== "clocked") {
-        refuse(`Grok training subject ${agentId} requires a broker slot provisioned and attested with workerConfigVariant: clocked`);
-    }
-    return engine;
-};

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

@@ -1,115 +0,0 @@
-import { DAIMON_BROKER_ENGINE_ID, DAIMON_PORTABLE_ENGINE_ID } from "../../runtime/daimon/index.js";
-import type { Socket } from "node:net";
-import { DAIMON_GROK_ENGINE_BROKER, type DaimonGrokBrokerModel, type DaimonGrokBrokerReasoningEffort } from "../../runtime/daimon/contractManifest.js";
-/** The training core's slot freshness floor for this trial: the receipt must echo the nonce at no lower generation. */
-export interface TrainingSubjectFreshness {
-    expectedNonce: string;
-    minGeneration: number;
-}
-/** The evaluator-created per-trial directories (`TrialPaths`); only Codex subjects live in them. */
-export interface TrainingSubjectTrialRoots {
-    workspace: string;
-    runtimeHome: string;
-}
-export type TrainingSubjectEvaluatorRole = "run-root" | "context" | "sealed-inputs" | "judge-home" | "slot-ledger";
-/** `spawnfile.training.daimon-native.launch.v2` `broker`, structurally `grokBrokerLaunchSchema` in the bundled native adapter. */
-export interface TrainingSubjectBrokerSection {
-    projectionVersion: typeof DAIMON_GROK_ENGINE_BROKER.projectionVersion;
-    workerConfigVariant: "unclocked" | "clocked";
-    projectionSha256: string;
-    slot: number;
-    workerUid: number;
-    workerHomePath: string;
-    architecture: "arm64" | "x64";
-    usageLedgerPath: string;
-    seccompProfileSha256: string;
-    profileSha256: string;
-    denyPaths: string[];
-    limits: {
-        maxRequests: number;
-        maxTokens: number;
-        timeoutMs: number;
-    };
-    evaluatorPaths: {
-        role: TrainingSubjectEvaluatorRole;
-        path: string;
-    }[];
-    slotPreflightReceipt: string;
-    expectedNonce: string;
-    minGeneration: number;
-}
-export type TrainingSubjectAgent = {
-    id: string;
-    engine: typeof DAIMON_PORTABLE_ENGINE_ID;
-    model: string;
-} | {
-    id: string;
-    engine: typeof DAIMON_BROKER_ENGINE_ID;
-    model: DaimonGrokBrokerModel;
-    reasoningEffort: DaimonGrokBrokerReasoningEffort;
-};
-export interface TrainingSubjectLease {
-    agent: TrainingSubjectAgent;
-    workspace: {
-        source: string;
-        target: string;
-    };
-    projections: {
-        role: "home" | "memory" | "transport" | "subscription";
-        source: string;
-        target: string;
-    }[];
-    credentials: {
-        source: string;
-        target: string;
-    }[];
-    broker?: TrainingSubjectBrokerSection;
-    /** Named slot roots: always `workspace`, `home` and `control`, plus engine-specific roots (Grok adds `context`). */
-    roots: Record<string, string> & {
-        workspace: string;
-        home: string;
-        control: string;
-    };
-    /** `control` is the worker control port; `moltnet` and `bridge` are provisioner-owned extras. */
-    ports: {
-        moltnet: number;
-        control: number;
-        bridge: number;
-    };
-    /** Recycled generation; Grok only. */
-    generation?: number;
-    /** Subject environment Spawnfile owns for this lease. */
-    env: Record<string, string>;
-}
-export interface LeaseTrainingSubjectOptions {
-    slot: number;
-    engine: string;
-    agentId: string;
-    /** The compiled Codex model; Grok's model comes from the broker declaration and, if given, must match it. */
-    model?: string;
-    /** Required for Grok, refused for Codex (which has no recycle). */
-    freshness?: TrainingSubjectFreshness;
-    /** Required for Codex; a Grok subject lives at the container's fixed slot roots. */
-    trialRoots?: TrainingSubjectTrialRoots;
-    signal: AbortSignal;
-    /** Resolves Daimon's public `Daimon/runtime` export. */
-    loadDaimon?: () => Promise<unknown>;
-    /** Test seams: the supervisor connection and the declaration file. */
-    connect?: () => Socket;
-    declarationFile?: string;
-    slotsFile?: string;
-}
-/** The fixed read-only container leaf the training launch binds the Codex login to. */
-export declare const TRAINING_CODEX_CREDENTIAL_INGRESS = "/run/spawnfile-training-auth/codex";
-/**
- * Lease one training slot for an engine-neutral subject and return everything
- * `spawnfile.training.daimon-native.launch.v2` must carry about it.
- *
- * Spawnfile owns the container, its slots, the broker declaration and
- * registration, the projection inputs, the recycle verb and the credential
- * ingress paths, so an integration names an engine and an agent and never a
- * container path. Grok recycles the slot with the evaluator's nonce and binds
- * the supervisor's receipt; Codex derives its per-trial projections from the
- * evaluator's own trial roots. Any other engine is refused.
- */
-export declare const leaseTrainingSubject: (options: LeaseTrainingSubjectOptions) => Promise<TrainingSubjectLease>;