spawnfile 0.1.17 → 0.1.18

package/dist/compiler/training/plan/references.d.ts

@@ -0,0 +1,19 @@
+import type { CompilePlan, ResolvedAgentNode } from "../../types.js";
+import type { ResolvedWorkspaceResource } from "../../workspaceResources.js";
+import type { TrainingPlanOverride } from "./contract.js";
+import type { TrainingAgentNode } from "./types.js";
+export declare const invalidTraining: (message: string) => never;
+export declare const lexical: (left: string, right: string) => number;
+/** Shared selection for the authoring plan and runtime recording; resolved visibility is authoritative. */
+export declare const resolveTrainingRecordVolumes: (agent: {
+    id: string;
+    value: ResolvedAgentNode;
+}) => Array<ResolvedWorkspaceResource & {
+    kind: "volume";
+}>;
+export declare const resolveTrainingResource: (plan: CompilePlan, agent: TrainingAgentNode, id: string, context: string) => {
+    resource: ResolvedWorkspaceResource;
+    declaredBy: string;
+};
+/** Uses compiler-resolved visibility, including shared banks and representative attachments. */
+export declare const resolveTrainingOverride: (plan: CompilePlan, agent: TrainingAgentNode, section: TrainingPlanOverride["section"], id: string, context: string) => TrainingPlanOverride;

package/dist/compiler/training/plan/references.js

@@ -0,0 +1,57 @@
+import { SpawnfileError } from "../../../shared/index.js";
+export const invalidTraining = (message) => {
+    throw new SpawnfileError("validation_error", message);
+};
+export const lexical = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const declaredId = (plan, source) => plan.nodes.find((node) => node.value.source === source)?.id
+    ?? invalidTraining(`Training reference has no declaring node: ${source}`);
+const one = (matches, id, context) => {
+    if (matches.length === 0)
+        invalidTraining(`${context}: unknown id ${id}`);
+    if (matches.length > 1)
+        invalidTraining(`${context}: ambiguous id ${id}`);
+    return matches[0];
+};
+/** Shared selection for the authoring plan and runtime recording; resolved visibility is authoritative. */
+export const resolveTrainingRecordVolumes = (agent) => (agent.value.training?.record?.volumes ?? []).map((id) => {
+    const context = `Training record.volumes for ${agent.id}`;
+    const resource = one((agent.value.workspaceResources ?? []).filter((entry) => entry.id === id), id, context);
+    if (resource.kind !== "volume")
+        return invalidTraining(`${context}: ${id} must be a volume`);
+    if (resource.feed)
+        return invalidTraining(`${context}: fed volume ${id} is recorded through its landing log`);
+    return resource;
+}).sort((left, right) => lexical(left.id, right.id));
+export const resolveTrainingResource = (plan, agent, id, context) => {
+    const resource = one((agent.value.workspaceResources ?? []).filter((entry) => entry.id === id), id, context);
+    return { resource, declaredBy: declaredId(plan, resource.scope.key) };
+};
+/** Uses compiler-resolved visibility, including shared banks and representative attachments. */
+export const resolveTrainingOverride = (plan, agent, section, id, context) => {
+    let declaredBy;
+    if (section === "resources") {
+        declaredBy = resolveTrainingResource(plan, agent, id, context).declaredBy;
+    }
+    else if (section === "memory") {
+        // Multiple member slots can expose the same bank. They are one item, not ambiguity.
+        const sources = [...new Set((agent.value.memoryAccess ?? [])
+                .filter((entry) => entry.bank.id === id).map((entry) => entry.source))];
+        declaredBy = declaredId(plan, one(sources, id, context));
+    }
+    else {
+        const attachedSources = new Set();
+        for (const attachment of agent.value.surfaces?.moltnet ?? []) {
+            if (attachment.network !== id)
+                continue;
+            if (attachment.teamSource)
+                attachedSources.add(attachment.teamSource);
+            for (const source of Object.keys(attachment.contextRooms ?? {}))
+                attachedSources.add(source);
+        }
+        const matches = plan.nodes.filter((node) => node.value.kind === "team"
+            && attachedSources.has(node.value.source)
+            && node.value.networks?.some((network) => network.id === id));
+        declaredBy = one(matches, id, context).id;
+    }
+    return { section, id, declaredBy };
+};

package/dist/compiler/training/plan/resolve.d.ts

@@ -0,0 +1,4 @@
+import { type TrainingPlan } from "./contract.js";
+import type { LoadedTrainingProject } from "./types.js";
+/** Pure projection over loaded facts: no filesystem, clock, execution, or mutation. */
+export declare const resolveTrainingPlan: (project: LoadedTrainingProject, agentId: string | undefined, producerVersion: string) => TrainingPlan;

package/dist/compiler/training/plan/resolve.js

@@ -0,0 +1,73 @@
+import { selectTrainingAgent } from "../selection.js";
+import { TRAINING_PLAN_VERSION, trainingPlanSchema } from "./contract.js";
+import { invalidTraining, lexical, resolveTrainingRecordVolumes, resolveTrainingResource } from "./references.js";
+import { planGrader, resolveTrainingTarget, trainingAgents } from "./targets.js";
+const optimizerFor = (agent, hasTargets) => {
+    const optimizer = agent.value.training?.optimizer;
+    const required = ["method", "model", "variants", "keep"];
+    const missing = required.filter((key) => optimizer?.[key] === undefined);
+    if (optimizer?.budget?.rounds === undefined)
+        missing.push("budget.rounds");
+    if (missing.length > 0) {
+        if (hasTargets)
+            invalidTraining(`Training optimizer for ${agent.id} is missing fields: ${missing.join(", ")}`);
+        return null;
+    }
+    if (hasTargets && optimizer.keep > optimizer.variants) {
+        invalidTraining(`Training optimizer for ${agent.id} requires keep <= variants`);
+    }
+    return {
+        method: optimizer.method, model: optimizer.model, variants: optimizer.variants, keep: optimizer.keep,
+        budget: { rounds: optimizer.budget.rounds }
+    };
+};
+const recordFor = (project, agent) => {
+    const record = agent.value.training?.record;
+    if (record === undefined)
+        return null;
+    return {
+        keep: record.keep ?? null,
+        volumes: resolveTrainingRecordVolumes(agent).map(({ id }) => {
+            const context = `Training record.volumes for ${agent.id}`;
+            const { declaredBy } = resolveTrainingResource(project.compilePlan, agent, id, context);
+            return { id, declaredBy };
+        })
+    };
+};
+/** JSON key ordering is part of the deterministic public representation. */
+const sortKeys = (value) => {
+    if (Array.isArray(value))
+        return value.map(sortKeys);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => lexical(left, right)).map(([key, item]) => [key, sortKeys(item)]));
+    return value;
+};
+/** Pure projection over loaded facts: no filesystem, clock, execution, or mutation. */
+export const resolveTrainingPlan = (project, agentId, producerVersion) => {
+    const agents = trainingAgents(project);
+    const selected = selectTrainingAgent(agents, agentId);
+    const graders = Object.entries(selected.value.training?.graders ?? {})
+        .map(([name, grader]) => planGrader(project, name, grader));
+    const targets = [];
+    for (const target of project.targets) {
+        const resolved = resolveTrainingTarget(project, target, selected.id);
+        if (!resolved)
+            continue;
+        targets.push(resolved.target);
+        graders.push(resolved.grader);
+    }
+    const uniqueGraders = [...new Map(graders.map((grader) => [JSON.stringify(sortKeys(grader)), grader])).values()];
+    uniqueGraders.sort((left, right) => lexical(`${left.name}:${left.declaredBy}:${left.path}`, `${right.name}:${right.declaredBy}:${right.path}`));
+    targets.sort((left, right) => lexical(JSON.stringify(sortKeys(left)), JSON.stringify(sortKeys(right))));
+    const plan = trainingPlanSchema.parse({
+        version: TRAINING_PLAN_VERSION,
+        producer: { package: "spawnfile", version: producerVersion },
+        project: { root: project.root, manifest: project.manifest },
+        agent: { id: selected.id, name: selected.value.name },
+        deadlines: { experiment_ms: 43_200_000, ...selected.value.training?.deadlines },
+        ...(selected.value.training?.preparation ? { preparation: selected.value.training.preparation } : {}),
+        record: recordFor(project, selected), optimizer: optimizerFor(selected, targets.length > 0),
+        graders: uniqueGraders, targets
+    });
+    return sortKeys(plan);
+};

package/dist/compiler/training/plan/targets.d.ts

@@ -0,0 +1,11 @@
+import type { TrainingPlan } from "./contract.js";
+import type { LoadedTrainingProject, LoadedTrainingTarget, TrainingAgentNode } from "./types.js";
+export declare const trainingAgents: (project: LoadedTrainingProject) => TrainingAgentNode[];
+export declare const planGrader: (project: LoadedTrainingProject, name: string, reference: {
+    sourcePath: string;
+    declaredBy: string;
+}) => TrainingPlan["graders"][number];
+export declare const resolveTrainingTarget: (project: LoadedTrainingProject, target: LoadedTrainingTarget, selectedId: string) => {
+    target: TrainingPlan["targets"][number];
+    grader: TrainingPlan["graders"][number];
+} | null;

package/dist/compiler/training/plan/targets.js

@@ -0,0 +1,71 @@
+import path from "node:path";
+import { invalidTraining, lexical, resolveTrainingOverride } from "./references.js";
+const inside = (root, file) => {
+    const relative = path.relative(root, file);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+};
+export const trainingAgents = (project) => project.compilePlan.nodes.filter((node) => node.value.kind === "agent");
+const targetFile = (file, target, agents) => {
+    const context = `Training target ${file.sourcePath} declared by ${target.declaredBy}`;
+    if (file.error)
+        invalidTraining(`${context}: ${file.error}`);
+    if (!file.realPath || !inside(target.directory, file.sourcePath) || !inside(target.realDirectory, file.realPath)) {
+        invalidTraining(`${context} must be inside its declaring manifest directory (no symlink escape)`);
+    }
+    if (!file.regular || !file.sourcePath.endsWith(".md"))
+        invalidTraining(`${context} must be an existing regular .md file`);
+    if (file.nestedManifests.length > 0)
+        invalidTraining(`${context} belongs to a nested Spawnfile: ${file.nestedManifests.join(", ")}`);
+    const consumers = agents.filter((agent) => [...agent.value.docs, ...agent.value.skills]
+        .some((entry) => entry.sourcePath === file.sourcePath)).map((agent) => agent.id).sort(lexical);
+    if (consumers.length === 0)
+        invalidTraining(`${context} is not consumed by any agent document or skill`);
+    return { sourcePath: file.sourcePath, path: file.path, consumers };
+};
+export const planGrader = (project, name, reference) => {
+    const grader = project.graders[reference.sourcePath]
+        ?? invalidTraining(`Training grader ${name} declared by ${reference.declaredBy} was not loaded: ${reference.sourcePath}`);
+    return {
+        name, declaredBy: reference.declaredBy, sourcePath: grader.sourcePath, path: grader.path
+    };
+};
+const datasetFor = (project, target, agent, sourcePath) => {
+    const dataset = project.datasets[sourcePath]
+        ?? invalidTraining(`Training dataset ${sourcePath} declared by ${target.declaredBy} was not loaded`);
+    return {
+        sourcePath: dataset.sourcePath, path: dataset.path,
+        examples: dataset.value.examples.map((example) => ({
+            id: example.id, at: example.at, wake: { ...example.wake },
+            overrides: ["resources", "memory", "networks"].flatMap((section) => (example[section] ?? []).map((entry) => resolveTrainingOverride(project.compilePlan, agent, section, entry.id, `Training dataset ${sourcePath} example ${example.id} declared by ${target.declaredBy} for ${agent.id} ${section}`))).sort((left, right) => lexical(`${left.section}:${left.id}:${left.declaredBy}`, `${right.section}:${right.id}:${right.declaredBy}`))
+        })).sort((left, right) => lexical(left.id, right.id))
+    };
+};
+export const resolveTrainingTarget = (project, target, selectedId) => {
+    const agents = trainingAgents(project);
+    const files = target.files.map((file) => targetFile(file, target, agents)).sort((left, right) => lexical(left.path, right.path));
+    const declaringNode = project.compilePlan.nodes.find((node) => node.id === target.declaredBy)
+        ?? invalidTraining(`Unknown training declaring node ${target.declaredBy}`);
+    const registry = declaringNode.value.training?.graders ?? {};
+    const reference = (Object.hasOwn(registry, target.declaration.grader) ? registry[target.declaration.grader] : undefined)
+        ?? invalidTraining(`Training target declared by ${target.declaredBy} references unknown grader ${target.declaration.grader}`);
+    const grader = planGrader(project, target.declaration.grader, reference);
+    const consumerIds = new Set(files.flatMap((file) => file.consumers));
+    const checkedAgents = target.kind === "team"
+        ? agents.filter((agent) => consumerIds.has(agent.id))
+        : agents.filter((agent) => agent.id === target.declaredBy);
+    const { train, validation, test } = target.declaration.datasets;
+    let selectedDatasets;
+    // Resolve every consumer even when the caller selects a different one.
+    for (const agent of checkedAgents) {
+        const datasets = {
+            train: datasetFor(project, target, agent, train),
+            validation: validation === undefined ? null : datasetFor(project, target, agent, validation),
+            test: datasetFor(project, target, agent, test)
+        };
+        if (agent.id === selectedId)
+            selectedDatasets = datasets;
+    }
+    return selectedDatasets ? {
+        target: { declaredBy: target.declaredBy, grader: target.declaration.grader, files, datasets: selectedDatasets }, grader
+    } : null;
+};

package/dist/compiler/training/plan/types.d.ts

@@ -0,0 +1,36 @@
+import type { TrainingDataset, TrainingTarget } from "../../../manifest/index.js";
+import type { CompilePlan, CompilePlanNode, ResolvedAgentNode } from "../../types.js";
+export interface TrainingFileSource {
+    sourcePath: string;
+    path: string;
+}
+/** Filesystem observations only; ownership decisions belong to the pure resolver. */
+export interface TrainingTargetFile extends TrainingFileSource {
+    realPath: string | null;
+    regular: boolean;
+    nestedManifests: string[];
+    error?: string;
+}
+export interface LoadedTrainingTarget {
+    declaredBy: string;
+    kind: "agent" | "team";
+    directory: string;
+    realDirectory: string;
+    declaration: TrainingTarget;
+    files: TrainingTargetFile[];
+}
+export interface LoadedTrainingDataset extends TrainingFileSource {
+    value: TrainingDataset;
+    sha256: string;
+}
+export interface LoadedTrainingProject {
+    root: string;
+    manifest: string;
+    compilePlan: CompilePlan;
+    targets: LoadedTrainingTarget[];
+    datasets: Record<string, LoadedTrainingDataset>;
+    graders: Record<string, TrainingFileSource>;
+}
+export type TrainingAgentNode = CompilePlanNode & {
+    value: ResolvedAgentNode;
+};

package/dist/compiler/training/plan/types.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/training/preparation/assets/Dockerfile

@@ -10,11 +10,22 @@ COPY --from=python /usr/lib/*-linux-gnu/libsqlite3.so.0* /opt/python/lib/
 # libraries in the image so Python extensions also load in that clean process.
 RUN echo /opt/python/lib > /etc/ld.so.conf.d/training-python.conf && ldconfig
 
+# Bookworm's distro library, shared by broker shell tools and direct clocked
+# Daimon children. Resolve the multiarch path at build time; never preload the image.
+RUN . /etc/os-release && test "$VERSION_CODENAME" = bookworm \
+ && apt-get update && apt-get install --yes --no-install-recommends libfaketime=0.9.10-2.1 \
+ && library="$(dpkg-query -L libfaketime | sed -n '\|/faketime/libfaketime\.so\.1$|p')" \
+ && test -f "$library" \
+ && install -d -o root -g root -m 0755 /usr/local/lib/daimon \
+ && ln -s "$library" /usr/local/lib/daimon/libfaketime.so.1 \
+ && chown -h root:root /usr/local/lib/daimon/libfaketime.so.1 \
+ && rm -rf /var/lib/apt/lists/*
+
 # The broker-capable container runs on a read-only root, so the fixed Daimon
 # identities are baked here instead of being created by the entrypoint the way
 # the production organization image creates them. It depends on nothing from the
 # build context, so it sits first: it is the least frequently changing layer.
-RUN for fixed_uid in 2000 2100 2200; do \
+RUN for fixed_uid in 2000 2100 2200 2201 2202 2203 2204 2205 2206 2207; do \
       groupadd -K GID_MIN=1 --gid "$fixed_uid" "daimon-$fixed_uid" \
    && useradd -K UID_MIN=1 --no-create-home --no-log-init --uid "$fixed_uid" --gid "$fixed_uid" \
         --home-dir /nonexistent --shell /usr/sbin/nologin "daimon-$fixed_uid"; \
@@ -27,7 +38,7 @@ RUN for fixed_uid in 2000 2100 2200; do \
 # CAP_DAC_OVERRIDE there cannot override an inode owned by real uid 0; and a fresh bind of the parent
 # re-exposes this same directory rather than the bytes under it. Nothing at runtime can widen it,
 # because the container root is read-only — the slot provisioning asserts the mode and refuses otherwise.
-RUN mkdir -p /run/training/inputs /run/training/output \
+RUN mkdir -p /run/training/inputs /run/training/output /run/training/slots \
  && chown 0:0 /run/training /run/training/output && chmod 0755 /run/training /run/training/output \
  && chown 0:2000 /run/training/inputs && chmod 0750 /run/training/inputs
 

package/dist/compiler/training/preparation/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "spawnfile",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "spawnfile",
-      "version": "0.1.17",
+      "version": "0.1.18",
       "license": "MIT",
       "dependencies": {
         "@noopolis/stele": "0.0.2",

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

@@ -9,8 +9,8 @@ export interface PreparedTrainingBroker {
     };
 }
 /**
- * Lowers `spawnfile.training-container.v3`'s broker block into the read-only
- * `spawnfile.training-broker.v1` declaration the container's own root
+ * Lowers `spawnfile.training-container.v4`'s broker block into the read-only
+ * `spawnfile.training-broker.v2` declaration the container's own root
  * entrypoint reads, plus the launch bindings that carry the realm volume and
  * bootstrap leaf.
  *
@@ -18,4 +18,4 @@ export interface PreparedTrainingBroker {
  * `docker create` — a dry run, a failed build — must still refuse the
  * developer's desktop Grok login rather than report it later.
  */
-export declare const prepareTrainingBroker: (broker: NonNullable<TrainingPreparationConfig["broker"]>, root: string, staging: string, write: boolean) => Promise<PreparedTrainingBroker>;
+export declare const prepareTrainingBroker: (broker: NonNullable<TrainingPreparationConfig["broker"]>, root: string, staging: string, write: boolean, slots?: number) => Promise<PreparedTrainingBroker>;

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

@@ -6,8 +6,8 @@ import { parseTrainingBrokerDeclaration } from "../broker/declaration.js";
 import { TRAINING_BOOTSTRAP_MOUNT } from "../broker/paths.js";
 import { DAIMON_ORGANIZATION_UID } from "../../../runtime/daimon/runtimeIdentity.js";
 /**
- * Lowers `spawnfile.training-container.v3`'s broker block into the read-only
- * `spawnfile.training-broker.v1` declaration the container's own root
+ * Lowers `spawnfile.training-container.v4`'s broker block into the read-only
+ * `spawnfile.training-broker.v2` declaration the container's own root
  * entrypoint reads, plus the launch bindings that carry the realm volume and
  * bootstrap leaf.
  *
@@ -15,7 +15,7 @@ import { DAIMON_ORGANIZATION_UID } from "../../../runtime/daimon/runtimeIdentity
  * `docker create` — a dry run, a failed build — must still refuse the
  * developer's desktop Grok login rather than report it later.
  */
-export const prepareTrainingBroker = async (broker, root, staging, write) => {
+export const prepareTrainingBroker = async (broker, root, staging, write, slots = 4) => {
     const bootstrap = path.resolve(root, broker.bootstrap);
     assertNotDesktopGrokAuth(bootstrap);
     const info = await lstat(bootstrap).catch(() => undefined);
@@ -24,7 +24,9 @@ export const prepareTrainingBroker = async (broker, root, staging, write) => {
     if ((info.mode & 0o077) !== 0)
         throw Error("The training Grok bootstrap must not be group- or world-accessible");
     const declaration = parseTrainingBrokerDeclaration({
-        version: "spawnfile.training-broker.v1",
+        version: "spawnfile.training-broker.v2",
+        slots,
+        maxRunRequests: broker.maxRunRequests,
         engine: broker.engine,
         agentId: broker.agentId,
         model: broker.model,

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

@@ -4,8 +4,8 @@ export declare const trainingBuildSchema: z.ZodObject<{
     nativeImage: z.ZodString;
     pythonImage: z.ZodString;
     platform: z.ZodEnum<{
-        "linux/arm64": "linux/arm64";
         "linux/amd64": "linux/amd64";
+        "linux/arm64": "linux/arm64";
     }>;
     paideia: z.ZodString;
     bridge: z.ZodString;
@@ -18,6 +18,7 @@ export declare const trainingBuildSchema: z.ZodObject<{
     integration: z.ZodObject<{
         source: z.ZodString;
         entry: z.ZodString;
+        execution: z.ZodOptional<z.ZodLiteral<"spawnfile.training-execution.v1">>;
     }, z.core.$strict>;
     bootstrap: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
@@ -31,6 +32,7 @@ export declare const trainingBuildSchema: z.ZodObject<{
  * No Grok binary and no Grok auth staging enter the image.
  */
 export declare const trainingBrokerSchema: z.ZodObject<{
+    maxRunRequests: z.ZodDefault<z.ZodNumber>;
     engine: z.ZodLiteral<"grok">;
     agentId: z.ZodString;
     model: z.ZodEnum<{
@@ -62,8 +64,10 @@ export declare const trainingBrokerSchema: z.ZodObject<{
 export declare const trainingPreparationSchema: z.ZodObject<{
     version: z.ZodEnum<{
         "spawnfile.training-container.v3": "spawnfile.training-container.v3";
+        "spawnfile.training-container.v4": "spawnfile.training-container.v4";
         "spawnfile.training-container.v2": "spawnfile.training-container.v2";
     }>;
+    slots: z.ZodDefault<z.ZodNumber>;
     dockerContext: z.ZodString;
     image: z.ZodUnion<readonly [z.ZodObject<{
         ref: z.ZodString;
@@ -73,8 +77,8 @@ export declare const trainingPreparationSchema: z.ZodObject<{
             nativeImage: z.ZodString;
             pythonImage: z.ZodString;
             platform: z.ZodEnum<{
-                "linux/arm64": "linux/arm64";
                 "linux/amd64": "linux/amd64";
+                "linux/arm64": "linux/arm64";
             }>;
             paideia: z.ZodString;
             bridge: z.ZodString;
@@ -87,6 +91,7 @@ export declare const trainingPreparationSchema: z.ZodObject<{
             integration: z.ZodObject<{
                 source: z.ZodString;
                 entry: z.ZodString;
+                execution: z.ZodOptional<z.ZodLiteral<"spawnfile.training-execution.v1">>;
             }, z.core.$strict>;
             bootstrap: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
@@ -122,7 +127,27 @@ export declare const trainingPreparationSchema: z.ZodObject<{
             claude: "claude";
         }>;
     }, z.core.$strict>>;
+    evaluatorRoutes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        purpose: z.ZodEnum<{
+            decisions: "decisions";
+            extraction: "extraction";
+            proposals: "proposals";
+        }>;
+        provider: z.ZodEnum<{
+            "codex-subscription": "codex-subscription";
+            typesafe: "typesafe";
+        }>;
+        model: z.ZodString;
+        maxRequests: z.ZodNumber;
+        maxSpendUsd: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    evaluatorSecrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        provider: z.ZodLiteral<"typesafe">;
+        source: z.ZodString;
+    }, z.core.$strict>>>;
+    subjectIsolation: z.ZodOptional<z.ZodLiteral<"codex-native-sandbox">>;
     broker: z.ZodOptional<z.ZodObject<{
+        maxRunRequests: z.ZodDefault<z.ZodNumber>;
         engine: z.ZodLiteral<"grok">;
         agentId: z.ZodString;
         model: z.ZodEnum<{

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

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { z } from "zod";
+import { trainingEvaluatorRoutesSchema, trainingEvaluatorSecretsSchema } from "../container/evaluators.js";
 import { trainingImageSchema } from "../container/contract.js";
+import { TRAINING_EXECUTION_VERSION } from "../contract.js";
 import { DAIMON_GROK_BROKER_MODELS, DAIMON_GROK_BROKER_REASONING_EFFORTS, DAIMON_GROK_ENGINE_BROKER } from "../../../runtime/daimon/contractManifest.js";
 const local = z.string().min(1).refine(value => !/[,\r\n\0]/u.test(value));
 const relative = local.refine(value => !path.isAbsolute(value) && !value.includes("\\") && value.split("/").every(part => part !== "" && part !== "." && part !== ".." && part !== ".git"));
@@ -18,7 +20,8 @@ export const trainingBuildSchema = z.object({
      * could only ever be a different, unattested build.
      */
     grok: z.object({ source: local, sha256: sha }).strict().optional(),
-    integration: z.object({ source: local, entry: relative.refine(value => /^[A-Za-z0-9._/-]+$/u.test(value)) }).strict(), bootstrap: local.optional()
+    integration: z.object({ source: local, entry: relative.refine(value => /^[A-Za-z0-9._/-]+$/u.test(value)),
+        execution: z.literal(TRAINING_EXECUTION_VERSION).optional() }).strict(), bootstrap: local.optional()
 }).strict();
 const bounds = DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds;
 /**
@@ -31,6 +34,7 @@ const bounds = DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds;
  * No Grok binary and no Grok auth staging enter the image.
  */
 export const trainingBrokerSchema = z.object({
+    maxRunRequests: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(1000),
     engine: z.literal("grok"),
     agentId: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u),
     model: z.enum(DAIMON_GROK_BROKER_MODELS),
@@ -48,7 +52,8 @@ export const trainingBrokerSchema = z.object({
     unenforcedBindPolicy: z.enum(["refuse", "profile-only"]).optional()
 }).strict();
 export const trainingPreparationSchema = z.object({
-    version: z.enum(["spawnfile.training-container.v2", "spawnfile.training-container.v3"]),
+    version: z.enum(["spawnfile.training-container.v2", "spawnfile.training-container.v3", "spawnfile.training-container.v4"]),
+    slots: z.number().int().min(1).max(8).default(4),
     dockerContext: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u),
     image: z.union([z.object({ ref: trainingImageSchema }).strict(), z.object({ build: trainingBuildSchema }).strict()]),
     integration: z.object({ settings: reference }).strict(),
@@ -61,10 +66,24 @@ export const trainingPreparationSchema = z.object({
     }).strict()).min(1).max(64),
     output: z.object({ source: local, destination: z.literal("/run/training/output") }).strict(),
     auth: z.array(z.object({ source: local, provider: z.enum(["codex", "claude"]) }).strict()).max(2),
+    evaluatorRoutes: trainingEvaluatorRoutesSchema.optional(),
+    evaluatorSecrets: trainingEvaluatorSecretsSchema(local).optional(),
+    subjectIsolation: z.literal("codex-native-sandbox").optional(),
     broker: trainingBrokerSchema.optional()
 }).strict().superRefine((value, context) => {
-    if ((value.version === "spawnfile.training-container.v3") !== (value.broker !== undefined)) {
-        context.addIssue({ code: "custom", message: "Only spawnfile.training-container.v3 declares a broker slot, and it always does" });
+    if (value.evaluatorSecrets && !value.broker && !value.subjectIsolation)
+        context.addIssue({ code: "custom", message: "Evaluator secrets require brokered v4 isolation or explicit codex-native-sandbox subject isolation" });
+    if (value.subjectIsolation && value.version !== "spawnfile.training-container.v2")
+        context.addIssue({ code: "custom", message: "Codex native subject isolation requires a non-brokered v2 preparation" });
+    if (value.subjectIsolation && !value.evaluatorRoutes?.some(route => route.provider === "typesafe"))
+        context.addIssue({ code: "custom", message: "Codex native subject isolation requires a TypeSafe evaluator route" });
+    if (value.evaluatorSecrets && !value.evaluatorRoutes?.some(route => route.provider === "typesafe")) {
+        context.addIssue({ code: "custom", message: "TypeSafe secret requires a declared evaluator route" });
+    }
+    if (value.version === "spawnfile.training-container.v3")
+        context.addIssue({ code: "custom", message: "Training-container v3 is unsupported; migrate to v4 with slots: 1" });
+    if ((value.version === "spawnfile.training-container.v4") !== (value.broker !== undefined)) {
+        context.addIssue({ code: "custom", message: "Only spawnfile.training-container.v4 declares broker slots; migrate v3 by setting version to v4 and slots to 1" });
     }
     if (value.broker && "build" in value.image && value.image.build.grok) {
         context.addIssue({ code: "custom", message: "A v3 training image never copies a Grok binary; judges use the native parent's pinned /usr/local/bin/grok" });

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

@@ -6,11 +6,13 @@ export interface SealedFile {
     sha256: string;
     mode: number;
     size: number;
+    target?: string;
+    directory?: true;
 }
 export declare function assertInputRoot(source: string, auth: readonly string[]): void;
 export declare function exactPath(source: string): Promise<string>;
 export declare function sealFile(source: string, destination: string): Promise<SealedFile>;
-/** Only explicitly selected trees are traversed. Symlinks never enter Docker context. */
+/** Only physical entries are walked; confined input links retain their own identity. */
 export declare function sealTree(source: string, destination: string, options?: {
     ignoreDevelopment?: boolean;
     ignoreGit?: boolean;
@@ -18,6 +20,8 @@ export declare function sealTree(source: string, destination: string, options?:
 }): Promise<SealedFile[]>;
 export declare function copySealed(files: readonly SealedFile[], root: string): Promise<void>;
 export declare const fileIdentity: (files: readonly SealedFile[]) => {
+    type?: "directory" | "symlink" | undefined;
+    target?: string | undefined;
     destination: string;
     sha256: string;
     mode: number;