spawnfile 0.1.13 → 0.1.17

package/dist/compiler/runProjectLifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { DockerRunInvocation, DockerRunResult, DockerRunRunner } from "./runProjectDocker.js";
+/**
+ * Docker consumes an env file before a detached container is started, so the
+ * generated copy must not become a durable credential store. Other files in
+ * the support directory may be active bind-mount sources and must remain.
+ */
+export declare const executeDockerRunWithSupportCleanup: (invocation: DockerRunInvocation, runner: DockerRunRunner) => Promise<DockerRunResult | void>;

package/dist/compiler/runProjectLifecycle.js

@@ -0,0 +1,40 @@
+import { rm } from "node:fs/promises";
+import { removeDirectory } from "../filesystem/index.js";
+/**
+ * Docker consumes an env file before a detached container is started, so the
+ * generated copy must not become a durable credential store. Other files in
+ * the support directory may be active bind-mount sources and must remain.
+ */
+export const executeDockerRunWithSupportCleanup = async (invocation, runner) => {
+    let started = false;
+    try {
+        const runInvocation = invocation.detach
+            ? {
+                ...invocation,
+                onDetachedStarted: async (result) => {
+                    await invocation.onDetachedStarted?.(result);
+                    started = true;
+                    await rm(invocation.envFilePath, { force: true });
+                }
+            }
+            : invocation;
+        const result = await runner(runInvocation);
+        if (invocation.detach) {
+            if (!started) {
+                started = true;
+                await rm(invocation.envFilePath, { force: true });
+            }
+        }
+        else {
+            started = true;
+            await removeDirectory(invocation.supportDirectory);
+        }
+        return result;
+    }
+    catch (error) {
+        if (!started) {
+            await removeDirectory(invocation.supportDirectory);
+        }
+        throw error;
+    }
+};

package/dist/compiler/syncProjectAuth.js

@@ -4,7 +4,7 @@ import { SpawnfileError } from "../shared/index.js";
 import { listAgentSurfaceSecretNames } from "./agentSurfaces.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { listMoltnetNetworkSecretNames } from "./compilePlanHelpers.js";
-import { listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from "./modelEnv.js";
+import { CLI_CREDENTIAL_SECRET_NAME, listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from "./modelEnv.js";
 const resolveAuthRequirements = async (inputPath) => {
     const plan = await buildCompilePlan(inputPath);
     const methods = new Set();
@@ -46,6 +46,9 @@ const resolveAuthRequirements = async (inputPath) => {
             methods.add(method);
         }
         for (const envName of listExecutionModelSecretNames(node.value.execution)) {
+            if (envName === CLI_CREDENTIAL_SECRET_NAME) {
+                continue;
+            }
             requiredEnvNames.add(envName);
             optionalEnvNames.delete(envName);
         }

package/dist/compiler/teamContextActiveEnvironments.d.ts

@@ -0,0 +1,13 @@
+import type { DiagnosticReport } from "../report/index.js";
+import type { CompileReportActiveEnvironments } from "../report/types.js";
+import type { AgentContext } from "./teamContextTypes.js";
+import type { CompilePlan, ResolvedAgentNode } from "./types.js";
+export type ActiveEnvironmentsIndex = CompileReportActiveEnvironments;
+export interface ActiveEnvironmentsResult {
+    activeEnvironments?: ActiveEnvironmentsIndex;
+    diagnostics: Array<{
+        source: string;
+        diagnostic: DiagnosticReport;
+    }>;
+}
+export declare const buildActiveEnvironments: (plan: CompilePlan, agentNode: ResolvedAgentNode, contexts: AgentContext[], directContextCount: number) => ActiveEnvironmentsResult;

package/dist/compiler/teamContextActiveEnvironments.js

@@ -0,0 +1,255 @@
+import { findTeamBySource, pathSafe } from "./teamContextHelpers.js";
+const ROOM_DERIVATION_RULE = "first_listed_room_member_containing_agent";
+const SCHEDULE_SINGLE_DIRECT_RULE = "single_direct_team_context_for_agent_schedule";
+const SCHEDULE_MULTI_CONTEXT_RULE = "multi_context_agent_schedule_uses_global_self";
+const agentSessionId = (agentNode) => pathSafe(agentNode.name);
+const getContextProfiles = (contexts) => contexts.map((context) => context.kind === "direct"
+    ? {
+        context,
+        contextKey: context.contextKey,
+        concreteMemberId: context.membership.memberId,
+        teamSource: context.teamNode.source
+    }
+    : {
+        context,
+        contextKey: context.contextKey,
+        concreteMemberId: context.representativeMemberId,
+        representedSlot: context.representedMember.id,
+        teamSource: context.parentTeamNode.source
+    });
+const contextKeyByMatch = {
+    direct: (teamSource, concreteMemberId) => `direct:${teamSource}:${concreteMemberId}`,
+    representative: (teamSource, representedSlot, concreteMemberId) => `representative:${teamSource}:${representedSlot}:${concreteMemberId}`
+};
+const findRoomMemberPosition = (plan, teamSource, networkId, roomId, memberSlot) => {
+    const teamNode = findTeamBySource(plan, teamSource);
+    if (!teamNode) {
+        return -1;
+    }
+    const network = teamNode.networks?.find((entry) => entry.id === networkId);
+    if (!network) {
+        return -1;
+    }
+    const room = network.rooms.find((entry) => entry.id === roomId);
+    if (!room) {
+        return -1;
+    }
+    return room.members.indexOf(memberSlot);
+};
+const deriveMoltnetEnvironments = (plan, agentNode, profiles) => {
+    const memberships = plan.moltnetRoomMemberships;
+    if (!memberships || memberships.length === 0) {
+        return { moltnet: undefined, diagnostics: [] };
+    }
+    const direct = new Map();
+    const representative = new Map();
+    const profileByContextKey = new Map();
+    for (const profile of profiles) {
+        profileByContextKey.set(profile.contextKey, profile);
+        if (profile.representedSlot === undefined) {
+            const key = contextKeyByMatch.direct(profile.teamSource, profile.concreteMemberId);
+            direct.set(key, [...(direct.get(key) ?? []), profile]);
+        }
+        else {
+            const key = contextKeyByMatch.representative(profile.teamSource, profile.representedSlot, profile.concreteMemberId);
+            representative.set(key, [...(representative.get(key) ?? []), profile]);
+        }
+    }
+    const diagnostics = [];
+    const byRoom = new Map();
+    for (const membership of memberships) {
+        if (membership.agentSource !== agentNode.source) {
+            continue;
+        }
+        const directProfiles = direct.get(contextKeyByMatch.direct(membership.directTeamSource, membership.concreteMemberId));
+        const representativeProfiles = membership.representedSlot
+            ? representative.get(contextKeyByMatch.representative(membership.declaringTeamSource, membership.representedSlot, membership.concreteMemberId))
+            : undefined;
+        const candidateProfiles = plan.organizationIdentity
+            ? profiles.filter((profile) => membership.representedSlot
+                ? profile.representedSlot === membership.representedSlot &&
+                    profile.teamSource === membership.declaringTeamSource
+                : profile.representedSlot === undefined &&
+                    profile.teamSource === membership.directTeamSource)
+            : membership.representedSlot
+                ? representativeProfiles
+                : directProfiles;
+        if (!candidateProfiles || candidateProfiles.length === 0) {
+            diagnostics.push({
+                source: membership.declaringTeamSource,
+                diagnostic: {
+                    level: "error",
+                    message: `Unable to derive active moltnet context for ${agentNode.name} in ${membership.networkId}/${membership.roomId}`
+                }
+            });
+            continue;
+        }
+        const memberPosition = findRoomMemberPosition(plan, membership.declaringTeamSource, membership.networkId, membership.roomId, membership.declaredSlot);
+        if (memberPosition === -1) {
+            diagnostics.push({
+                source: membership.declaringTeamSource,
+                diagnostic: {
+                    level: "error",
+                    message: `Unable to locate room member ${membership.declaredSlot} for ${membership.networkId}/${membership.roomId} in ${agentNode.name}`
+                }
+            });
+            continue;
+        }
+        const roomKey = `${membership.networkId}\u0000${membership.roomId}`;
+        byRoom.set(roomKey, [
+            ...(byRoom.get(roomKey) ?? []),
+            ...candidateProfiles.map((profile) => ({ profile, memberPosition }))
+        ]);
+    }
+    const moltnet = {};
+    for (const [roomBindingKey, candidates] of byRoom) {
+        if (candidates.length === 0) {
+            continue;
+        }
+        const roomKeyed = new Map();
+        for (const candidate of candidates) {
+            const existing = roomKeyed.get(candidate.profile.contextKey);
+            if (!existing || candidate.memberPosition < existing.memberPosition) {
+                roomKeyed.set(candidate.profile.contextKey, candidate);
+            }
+        }
+        const selected = [...roomKeyed.values()].sort((left, right) => {
+            if (left.memberPosition !== right.memberPosition) {
+                return left.memberPosition - right.memberPosition;
+            }
+            return left.profile.contextKey.localeCompare(right.profile.contextKey);
+        })[0];
+        if (!selected) {
+            continue;
+        }
+        const [networkId, roomId] = roomBindingKey.split("\u0000");
+        if (!networkId || !roomId) {
+            continue;
+        }
+        const profile = profileByContextKey.get(selected.profile.contextKey);
+        if (!profile) {
+            continue;
+        }
+        moltnet[networkId] ??= { rooms: {} };
+        moltnet[networkId].rooms[roomId] = {
+            context_key: profile.contextKey,
+            derivation: {
+                member_position: selected.memberPosition,
+                rule: ROOM_DERIVATION_RULE
+            },
+            member_slot: profile.representedSlot ?? profile.concreteMemberId,
+            roster: `.spawnfile/rosters/${profile.contextKey}.yaml`,
+            team_id: profile.contextKey,
+            team_doc: `.spawnfile/team-contexts/${profile.contextKey}/TEAM.md`,
+            session_key: `${agentSessionId(agentNode)}@moltnet:${networkId}:room:${roomId}`,
+            memory: {
+                durable_scope: {
+                    qualifier: profile.contextKey,
+                    scope: "team"
+                },
+                ephemeral_scope: {
+                    qualifier: `${networkId}:${roomId}`,
+                    scope: "room"
+                }
+            }
+        };
+    }
+    return {
+        moltnet: Object.keys(moltnet).length > 0 ? moltnet : undefined,
+        diagnostics
+    };
+};
+const deriveSchedules = (profiles, directContextCount, agentNode) => {
+    if (!agentNode.schedule || agentNode.schedule.kind === "disabled") {
+        return undefined;
+    }
+    const directProfile = directContextCount === 1
+        ? profiles.find((profile) => profile.context.kind === "direct")
+        : undefined;
+    const contextKey = directProfile ? directProfile.contextKey : "self";
+    return {
+        default: {
+            context_key: contextKey,
+            derivation: {
+                rule: directProfile ? SCHEDULE_SINGLE_DIRECT_RULE : SCHEDULE_MULTI_CONTEXT_RULE
+            },
+            environment_key: `schedule:${contextKey}`,
+            memory: {
+                durable_scope: {
+                    qualifier: directProfile ? directProfile.contextKey : agentSessionId(agentNode),
+                    scope: directProfile ? "team" : "global"
+                }
+            },
+            session_key: `${agentSessionId(agentNode)}@schedule:${contextKey}`
+        }
+    };
+};
+const hasAnyMemoryAccess = (agentNode) => (agentNode.memoryAccess?.length ?? 0) > 0 || (agentNode.memory?.length ?? 0) > 0;
+const resolveTeamMemoryScopes = (access) => {
+    if (access.declaringKind !== "team" || !access.slotId) {
+        return null;
+    }
+    return `${access.source}::${access.slotId}`;
+};
+const deriveDreams = (agentNode, profiles) => {
+    const dreams = {};
+    if (hasAnyMemoryAccess(agentNode)) {
+        dreams.self = {
+            context_key: "self",
+            environment_key: "dream:self",
+            memory: {
+                durable_scope: {
+                    qualifier: agentSessionId(agentNode),
+                    scope: "global"
+                }
+            },
+            session_key_template: `${agentSessionId(agentNode)}@dream:self:{run_id}`
+        };
+    }
+    const addProfileDream = (profile) => {
+        dreams[profile.contextKey] ??= {
+            context_key: profile.contextKey,
+            environment_key: `dream:${profile.contextKey}`,
+            memory: {
+                durable_scope: {
+                    qualifier: profile.contextKey,
+                    scope: "team"
+                }
+            },
+            session_key_template: `${agentSessionId(agentNode)}@dream:${profile.contextKey}:{run_id}`
+        };
+    };
+    if ((agentNode.memory?.length ?? 0) > 0) {
+        profiles.forEach(addProfileDream);
+    }
+    const profileByTeamSlot = new Map();
+    for (const profile of profiles) {
+        const key = `${profile.teamSource}::${profile.concreteMemberId}`;
+        profileByTeamSlot.set(key, [...(profileByTeamSlot.get(key) ?? []), profile]);
+    }
+    for (const access of agentNode.memoryAccess ?? []) {
+        const scopeKey = resolveTeamMemoryScopes(access);
+        if (!scopeKey) {
+            continue;
+        }
+        for (const profile of profileByTeamSlot.get(scopeKey) ?? []) {
+            addProfileDream(profile);
+        }
+    }
+    return Object.keys(dreams).length > 0 ? dreams : undefined;
+};
+export const buildActiveEnvironments = (plan, agentNode, contexts, directContextCount) => {
+    const profiles = getContextProfiles(contexts);
+    const moltnetResult = deriveMoltnetEnvironments(plan, agentNode, profiles);
+    const schedules = deriveSchedules(profiles, directContextCount, agentNode);
+    const dreams = deriveDreams(agentNode, profiles);
+    const activeEnvironments = {
+        ...(moltnetResult.moltnet ? { moltnet: moltnetResult.moltnet } : {}),
+        ...(schedules ? { schedules } : {}),
+        ...(dreams ? { dreams } : {})
+    };
+    if (Object.keys(activeEnvironments).length === 0) {
+        return { activeEnvironments: undefined, diagnostics: moltnetResult.diagnostics };
+    }
+    return { activeEnvironments, diagnostics: moltnetResult.diagnostics };
+};

package/dist/compiler/teamContextSupport.js

@@ -1,5 +1,6 @@
 import YAML from "yaml";
-import { buildContextOrientation, collectMoltnetBindings, createContextBaseKey, createVisibleTeamCards, findAgentBySource, findTeamBySource, getSystemTeamDoc, reportKeySegment, shortHash } from "./teamContextHelpers.js";
+import { buildContextOrientation, collectMoltnetBindings, createContextBaseKey, createVisibleTeamCards, findTeamBySource, getSystemTeamDoc, reportKeySegment, shortHash } from "./teamContextHelpers.js";
+import { buildActiveEnvironments } from "./teamContextActiveEnvironments.js";
 import { generateTeamRoster, listTeamRepresentatives } from "./teamRoster.js";
 const assignContextKeys = (contexts) => {
     const baseCounts = new Map();
@@ -84,6 +85,11 @@ const createTeamCapabilities = (teamNode) => [
         message: "Team context orientation was surfaced through runtime system instructions",
         outcome: "supported"
     },
+    {
+        key: "team.active_environments",
+        message: "Derived active environment bindings were emitted in team-contexts.yaml",
+        outcome: "supported"
+    },
     {
         key: "team.representatives",
         message: "Representative chains were resolved",
@@ -134,44 +140,11 @@ const createRepresentativeDiagnostics = (plan, teamNode) => {
     }
     return diagnostics;
 };
-const addAmbiguousBindingDiagnostics = (agentNode, contexts, diagnosticsByTeamSource) => {
-    const bindings = new Map();
-    for (const context of contexts) {
-        const teamSource = context.kind === "direct"
-            ? context.membership.teamSource
-            : context.parentTeamNode.source;
-        const memberId = context.kind === "direct"
-            ? context.membership.memberId
-            : context.representativeMemberId;
-        for (const binding of collectMoltnetBindings(agentNode, teamSource, memberId)) {
-            for (const room of binding.rooms) {
-                const key = `moltnet:${binding.network}:${room}`;
-                bindings.set(key, [...(bindings.get(key) ?? []), context]);
-            }
-        }
-    }
-    for (const [binding, bindingContexts] of bindings) {
-        const uniqueKeys = [...new Set(bindingContexts.map((context) => context.contextKey))];
-        if (uniqueKeys.length < 2) {
-            continue;
-        }
-        for (const context of bindingContexts) {
-            const teamSource = context.kind === "direct"
-                ? context.membership.teamSource
-                : context.parentTeamNode.source;
-            addMapEntries(diagnosticsByTeamSource, teamSource, [
-                {
-                    level: "warn",
-                    message: `Agent ${agentNode.name} maps ${binding} to multiple team contexts: ${uniqueKeys.join(", ")}`
-                }
-            ]);
-        }
-    }
-};
 export const prepareTeamCompileSupport = async (plan) => {
     const capabilitiesByTeamSource = new Map();
     const diagnosticsByTeamSource = new Map();
     const filesByAgentSource = new Map();
+    const activeEnvironmentsByAgentSource = new Map();
     const contextsByAgent = collectAgentContexts(plan);
     for (const node of plan.nodes) {
         if (node.value.kind !== "team") {
@@ -180,12 +153,24 @@ export const prepareTeamCompileSupport = async (plan) => {
         addMapEntries(capabilitiesByTeamSource, node.value.source, createTeamCapabilities(node.value));
         addMapEntries(diagnosticsByTeamSource, node.value.source, createRepresentativeDiagnostics(plan, node.value));
     }
-    for (const [agentSource, contexts] of contextsByAgent) {
-        const agentNode = findAgentBySource(plan, agentSource);
-        if (!agentNode) {
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "agent") {
             continue;
         }
+        const agentNode = node.value;
+        const agentSource = agentNode.source;
+        const contexts = contextsByAgent.get(agentSource) ?? [];
         const directCount = contexts.filter((context) => context.kind === "direct").length;
+        const activeEnvironmentsResult = buildActiveEnvironments(plan, agentNode, contexts, directCount);
+        for (const { source, diagnostic } of activeEnvironmentsResult.diagnostics) {
+            addMapEntries(diagnosticsByTeamSource, source, [diagnostic]);
+        }
+        if (activeEnvironmentsResult.activeEnvironments !== undefined) {
+            activeEnvironmentsByAgentSource.set(agentSource, activeEnvironmentsResult.activeEnvironments);
+        }
+        if (contexts.length === 0 && activeEnvironmentsResult.activeEnvironments === undefined) {
+            continue;
+        }
         const directIndex = [];
         const representationIndex = [];
         const files = [];
@@ -247,6 +232,9 @@ export const prepareTeamCompileSupport = async (plan) => {
             }
         }
         const contextIndex = {
+            ...(activeEnvironmentsResult.activeEnvironments
+                ? { active_environments: activeEnvironmentsResult.activeEnvironments }
+                : {}),
             direct_memberships: directIndex,
             representations: representationIndex
         };
@@ -258,7 +246,11 @@ export const prepareTeamCompileSupport = async (plan) => {
             path: ".spawnfile/team-contexts.md"
         });
         filesByAgentSource.set(agentSource, files);
-        addAmbiguousBindingDiagnostics(agentNode, contexts, diagnosticsByTeamSource);
     }
-    return { capabilitiesByTeamSource, diagnosticsByTeamSource, filesByAgentSource };
+    return {
+        activeEnvironmentsByAgentSource,
+        capabilitiesByTeamSource,
+        diagnosticsByTeamSource,
+        filesByAgentSource
+    };
 };

package/dist/compiler/teamContextTypes.d.ts

@@ -1,7 +1,9 @@
 import type { CapabilityReport, DiagnosticReport } from "../report/index.js";
+import type { ActiveEnvironmentsIndex } from "./teamContextActiveEnvironments.js";
 import type { EmittedFile } from "../runtime/index.js";
 import type { ResolvedMemberRef, ResolvedTeamMembershipContext, ResolvedTeamNode } from "./types.js";
 export interface TeamCompileSupport {
+    activeEnvironmentsByAgentSource: Map<string, ActiveEnvironmentsIndex>;
     capabilitiesByTeamSource: Map<string, CapabilityReport[]>;
     diagnosticsByTeamSource: Map<string, DiagnosticReport[]>;
     filesByAgentSource: Map<string, EmittedFile[]>;

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+/**
+ * `spawnfile.training-broker.v1`: the only thing the host tells the
+ * broker-capable training container about its slot. It is data, never code —
+ * the image's own Spawnfile distribution renders the provisioning from it with
+ * the same renderers production uses, so no host-written executable is ever
+ * mounted (`../container/AGENTS.md`).
+ *
+ * It carries no credentials: the training Grok login reaches the container only
+ * as the read-only bootstrap leaf bind, and the rotating credential lives on
+ * the named realm volume.
+ */
+export declare const trainingBrokerDeclarationSchema: z.ZodObject<{
+    version: z.ZodLiteral<"spawnfile.training-broker.v1">;
+    engine: z.ZodLiteral<"grok">;
+    agentId: z.ZodString;
+    model: z.ZodEnum<{
+        "grok-4.6": "grok-4.6";
+        "grok-4.5": "grok-4.5";
+        "grok-build": "grok-build";
+    }>;
+    reasoningEffort: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    architecture: z.ZodEnum<{
+        arm64: "arm64";
+        x64: "x64";
+    }>;
+    limits: z.ZodObject<{
+        maxRequests: z.ZodNumber;
+        maxTokens: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>;
+    bootstrap: z.ZodString;
+    organizationUid: z.ZodLiteral<2000>;
+    seccompProfileSha256: z.ZodString;
+    unenforcedBindPolicy: z.ZodDefault<z.ZodEnum<{
+        refuse: "refuse";
+        "profile-only": "profile-only";
+    }>>;
+}, z.core.$strict>;
+export type TrainingBrokerDeclaration = z.infer<typeof trainingBrokerDeclarationSchema>;
+export declare const parseTrainingBrokerDeclaration: (value: unknown) => TrainingBrokerDeclaration;

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

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { z } from "zod";
+import { DAIMON_GROK_BROKER_MODELS, DAIMON_GROK_BROKER_REASONING_EFFORTS, DAIMON_GROK_ENGINE_BROKER } from "../../../runtime/daimon/contractManifest.js";
+const canonical = z.string().min(2).max(4_096).refine((value) => path.posix.isAbsolute(value) && path.posix.normalize(value) === value && !value.endsWith("/") && !value.includes("\0"), "canonical absolute path");
+/**
+ * `spawnfile.training-broker.v1`: the only thing the host tells the
+ * broker-capable training container about its slot. It is data, never code —
+ * the image's own Spawnfile distribution renders the provisioning from it with
+ * the same renderers production uses, so no host-written executable is ever
+ * mounted (`../container/AGENTS.md`).
+ *
+ * It carries no credentials: the training Grok login reaches the container only
+ * as the read-only bootstrap leaf bind, and the rotating credential lives on
+ * the named realm volume.
+ */
+export const trainingBrokerDeclarationSchema = z.strictObject({
+    version: z.literal("spawnfile.training-broker.v1"),
+    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),
+    reasoningEffort: z.enum(DAIMON_GROK_BROKER_REASONING_EFFORTS),
+    architecture: z.enum(["arm64", "x64"]),
+    limits: z.strictObject({
+        maxRequests: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxRequests[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxRequests[1]),
+        maxTokens: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxTokens[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxTokens[1]),
+        timeoutMs: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.timeoutMs[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.timeoutMs[1])
+    }),
+    /** The read-only bootstrap credential leaf, already refused if it is the desktop `~/.grok/auth.json`. */
+    bootstrap: canonical,
+    /** The uid the trained evaluator (Paideia, DSPy, judges) runs as; the only uid the slot supervisor serves. */
+    organizationUid: z.literal(DAIMON_GROK_ENGINE_BROKER.identities.organizationUid),
+    seccompProfileSha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    /**
+     * What the slot supervisor does with a deny path whose backing filesystem
+     * does not enforce unix ownership — virtiofs and grpcfuse under Docker
+     * Desktop and Colima, where `chown` is silently ignored and uid 2200 reads a
+     * root `0600` file (P0 §5). The backing filesystem decides, not the fact of
+     * being a host bind: the same bind over ext4 or overlay on a Linux daemon is
+     * probed for real, which is what makes `refuse` a default a run can meet.
+     *
+     * `refuse` (the default) fails the slot and writes no receipt: a worker-uid
+     * probe over such a path carries no information, so the supervisor will not
+     * certify it. `profile-only` is the operator's explicit acceptance that for
+     * those paths the boundary is the bubblewrap-enforced `deny` list alone —
+     * verified to block both shell `cat` and `read_file` on 1.0.34 (P0 §4), but
+     * *not* a boundary a worker-uid namespace cannot lift — and the supervisor
+     * records every path that used that weaker evidence in its log.
+     *
+     * It does not reach `TRAINING_SEALED_DENY_PATHS`. The sealed train and test
+     * datasets are held by DAC on their ancestor under both values, and a slot
+     * that cannot prove that denial is refused whatever this says.
+     */
+    unenforcedBindPolicy: z.enum(["refuse", "profile-only"]).default("refuse")
+}).strict();
+export const parseTrainingBrokerDeclaration = (value) => trainingBrokerDeclarationSchema.parse(value);

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

@@ -0,0 +1,39 @@
+import { type DaimonProjectionModule } from "./projection.js";
+export declare const TRAINING_GROK_BROKER_CONTROL_SOCKET_ENV = "PAIDEIA_GROK_BROKER_CONTROL_SOCKET";
+export declare const TRAINING_GROK_GRANT_HOME_ROOT_ENV = "PAIDEIA_GROK_GRANT_HOME_ROOT";
+export declare const TRAINING_ENTRYPOINT_COMMAND = "/opt/training/bin/train";
+/**
+ * The desktop Grok login, in every spelling a caller might reach it by.
+ *
+ * D2 is explicit: training uses one dedicated Grok login and never the
+ * developer's own. An in-container refresh rotates the credential, so mounting
+ * the desktop leaf would invalidate the developer's desktop session as a side
+ * effect of a training run — and the refreshed token would live on tmpfs, so
+ * the desktop login would be gone rather than moved.
+ */
+export declare const desktopGrokAuthPaths: (home?: string) => string[];
+export declare const assertNotDesktopGrokAuth: (source: string, home?: string) => string;
+export interface TrainingEntrypointOptions {
+    argv: readonly string[];
+    declarationPath?: string;
+    loadDaimon?: () => Promise<DaimonProjectionModule>;
+    log?: (line: string) => void;
+}
+/**
+ * The broker-capable training container's root entrypoint.
+ *
+ * Order matters and is the whole privilege model: provision as root with the
+ * production capability set, start the launcher (root) and the broker and
+ * relay (2100) and prove each one's post-drop identity, publish the slot
+ * supervisor socket, and only then drop to uid 2000 with an empty capability
+ * bounding set to run `train`. Paideia, DSPy and the judges are that uid; the
+ * model's own tools are the worker uid the launcher alone can reach.
+ */
+export declare const runTrainingBrokerEntrypoint: (options: TrainingEntrypointOptions) => Promise<number>;
+/**
+ * `train` as uid 2000 with an empty bounding set, proven inside the child
+ * before it execs: `setpriv --bounding-set=-all` silently does nothing without
+ * `CAP_SETPCAP`, so the guard has to read `/proc/self/status` rather than
+ * trust the flag.
+ */
+export declare const trainingChildArgv: (argv: readonly string[], uid?: number) => string[];