spawnfile 0.1.32 → 0.1.34

package/dist/compiler/containerDaimonUidEntrypointRender.js

@@ -1,4 +1,4 @@
-import { DAIMON_ENGINE_DESCRIPTORS, DAIMON_SECRET_SERVICE_ENGINE_ID, getDaimonEngineDescriptor } from "../runtime/daimon/index.js";
+import { DAIMON_SECRET_SERVICE_ENGINE_ID, getDaimonEngineDescriptor } from "../runtime/daimon/index.js";
 import path from "node:path";
 import { DAIMON_RUNTIME_ACCEPTANCE_STORE_MOUNT_ID, DAIMON_WAKE_FUSE_DIRECTORY } from "../runtime/daimon/config.js";
 import { DAIMON_GROK_TURN_USAGE_LEDGER } from "../runtime/daimon/contractManifest.js";
@@ -9,37 +9,13 @@ import { renderDaimonOwnershipProgram, resolveDaimonVolumeIdentityFiles } from "
 export { resolveDaimonVolumeIdentityFiles } from "./containerDaimonOwnershipGuardRender.js";
 import { renderDaimonGrokHostPreflight } from "./containerDaimonGrokWorkerProvisioning.js";
 import { DAIMON_BROKER_EXECUTABLE, DAIMON_BROKER_BACKEND_SOCKET, DAIMON_BROKER_LAUNCHER_SOCKET, DAIMON_BROKER_REALM, DAIMON_BROKER_SOCKET, DAIMON_BROKER_TMPDIR, DAIMON_BROKER_UID, DAIMON_ORGANIZATION_UID, renderDaimonBrokerProvisioning, renderDaimonUsageLedgerProvisioning, resolveDaimonGrokRegistrations } from "./containerDaimonBrokerRender.js";
+import { renderDaimonStartupSupervision } from "./containerDaimonStartupSupervision.js";
+import { DAIMON_GATEWAY_UID, renderDaimonGatewayLaunch, renderDaimonGatewayProvisioning, renderDaimonGatewayRuntimeEnv, resolveDaimonGatewayRealmPaths } from "./containerDaimonGatewayRender.js";
+export { DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS, renderDaimonBrokerSocketWait } from "./containerDaimonStartupSupervision.js";
 export const DAIMON_AUTHORIZED_UID_ENV = "SPAWNFILE_DAIMON_AUTHORIZED_UID";
 export const DAIMON_RUNTIME_UID = DAIMON_ORGANIZATION_UID;
 export const DAIMON_UID_ENTRYPOINT_PATH = "/opt/spawnfile/daimon-uid-entrypoint.sh";
 export const DAIMON_RUNTIME_HOMES_DIRECTORY = "runtime-homes";
-export const DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS = 60;
-export const renderDaimonBrokerSocketWait = (timeoutSeconds = DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS, pollSeconds = 0.1) => [
-    `broker_startup_timeout_seconds=${timeoutSeconds}`,
-    `broker_startup_poll_seconds=${pollSeconds}`,
-    "broker_startup_started=$SECONDS",
-    "broker_process_status_root=/proc",
-    "wait_for_broker_socket() {",
-    "  socket=$1; child=$2; label=$3",
-    "  while [ ! -S \"$socket\" ]; do",
-    "    if ! kill -0 \"$child\" 2>/dev/null; then set +e; wait \"$child\"; child_status=$?; set -e; echo \"$label exited before readiness (status $child_status)\" >&2; return 1; fi",
-    "    if [ $((SECONDS - broker_startup_started)) -ge \"$broker_startup_timeout_seconds\" ]; then echo \"$label readiness timed out after ${broker_startup_timeout_seconds}s\" >&2; return 1; fi",
-    "    sleep \"$broker_startup_poll_seconds\"",
-    "  done",
-    "}",
-    "wait_for_broker_identity() {",
-    "  child=$1; expected_uid=$2; expected_caps=$3; label=$4",
-    "  while kill -0 \"$child\" 2>/dev/null; do",
-    "    status_path=$broker_process_status_root/$child/status",
-    "    observed_uid=$(awk '/^Uid:/{print $2}' \"$status_path\" 2>/dev/null || true)",
-    "    observed_caps=$(awk '/^CapBnd:/{print $2}' \"$status_path\" 2>/dev/null || true)",
-    "    if [ \"$observed_uid\" = \"$expected_uid\" ] && [ \"$observed_caps\" = \"$expected_caps\" ]; then return 0; fi",
-    "    if [ $((SECONDS - broker_startup_started)) -ge \"$broker_startup_timeout_seconds\" ]; then echo \"$label identity readiness timed out after ${broker_startup_timeout_seconds}s\" >&2; return 1; fi",
-    "    sleep \"$broker_startup_poll_seconds\"",
-    "  done",
-    "  set +e; wait \"$child\"; child_status=$?; set -e; echo \"$label exited before identity readiness (status $child_status)\" >&2; return 1",
-    "}"
-];
 const SPAWNFILE_PRIVATE_STATE_ROOT = "/var/lib/spawnfile";
 /**
  * `/var/lib/spawnfile/daimon` hosts several independently-owned children —
@@ -96,7 +72,8 @@ const writableStateRoots = (runtimePlans, persistentMountPaths) => [
 ].filter((root) => root.startsWith("/")
     && root !== DAIMON_BROKER_REALM
     && root !== DAIMON_GROK_TURN_USAGE_LEDGER.directoryPath
-    && root !== DAIMON_WAKE_FUSE_DIRECTORY).sort();
+    && root !== DAIMON_WAKE_FUSE_DIRECTORY
+    && !resolveDaimonGatewayRealmPaths(runtimePlans).includes(root)).sort();
 const privateDirectoriesThrough = (target) => {
     if (target !== SPAWNFILE_PRIVATE_STATE_ROOT &&
         !target.startsWith(`${SPAWNFILE_PRIVATE_STATE_ROOT}/`))
@@ -114,8 +91,6 @@ const privateModeDirectories = (runtimePlans, moltnet) => [
         .flatMap((plan) => plan.persistentMounts ?? [])
         .filter((mount) => mount.id === DAIMON_RUNTIME_ACCEPTANCE_STORE_MOUNT_ID
         || mount.id === DAIMON_AGY_SUBSCRIPTION_REALM_MOUNT_ID
-        || Object.values(DAIMON_ENGINE_DESCRIPTORS).some(({ id, auth }) => auth.staging === "portable-realm"
-            && mount.id === `daimon-${id}-subscription-realm` && mount.mount_path === auth.realm.durableMountPath)
         || mount.id.startsWith(DAIMON_AGY_RUNTIME_HOME_MOUNT_ID_PREFIX)
         || mount.id.startsWith(DAIMON_RECORDING_MOUNT_ID_PREFIX)
         || mount.id.startsWith(DAIMON_PORTABLE_ENGINE_HOME_MOUNT_ID_PREFIX))
@@ -206,6 +181,9 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
             .filter((runtimeRoot) => runtimeRoot.startsWith("/opt/spawnfile/runtime-installs/")))
     ].sort();
     const volumeIdentityFiles = resolveDaimonVolumeIdentityFiles(runtimePlans);
+    const grokRegistrations = resolveDaimonGrokRegistrations(runtimePlans);
+    const gateway = resolveDaimonGatewayRealmPaths(runtimePlans).length > 0;
+    const gatewayPid = gateway ? '"${gateway_pid:-}" ' : "";
     return [
         "#!/usr/bin/env bash",
         "set -euo pipefail",
@@ -222,13 +200,15 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
         ...createBackedMountGuard(persistentMounts),
         `state_roots=(${ownershipPlan.stateRoots.map(quote).join(" ")})`,
         "node - \"$uid\" \"${state_roots[@]}\" <<'SPAWNFILE_DAIMON_OWNERSHIP'",
-        renderDaimonOwnershipProgram(opaqueTargets, ownershipPlan.opaqueDescendantRoots, immutableRuntimeRoots, volumeIdentityFiles, ownershipPlan.privateDirectories, ownershipPlan.privateFiles, ownershipPlan.privateModeDirectories, ownershipPlan.creatablePrivateDirectories, resolveDaimonGrokRegistrations(runtimePlans).length > 0),
+        renderDaimonOwnershipProgram(opaqueTargets, ownershipPlan.opaqueDescendantRoots, immutableRuntimeRoots, volumeIdentityFiles, ownershipPlan.privateDirectories, ownershipPlan.privateFiles, ownershipPlan.privateModeDirectories, ownershipPlan.creatablePrivateDirectories, grokRegistrations.length > 0),
         "SPAWNFILE_DAIMON_OWNERSHIP",
-        `for fixed_uid in ${DAIMON_ORGANIZATION_UID} ${DAIMON_BROKER_UID} ${resolveDaimonGrokRegistrations(runtimePlans).map((entry) => entry.uid).join(" ")}; do`,
+        `for fixed_uid in ${DAIMON_ORGANIZATION_UID} ${DAIMON_BROKER_UID}${gateway ? ` ${DAIMON_GATEWAY_UID}` : ""} ${grokRegistrations.map((entry) => entry.uid).join(" ")}; do`,
         '  if ! getent group "$fixed_uid" >/dev/null; then groupadd -K GID_MIN=1 --gid "$fixed_uid" "daimon-$fixed_uid"; fi',
         '  if ! getent passwd "$fixed_uid" >/dev/null; then 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"; fi',
         "done",
-        ...(resolveDaimonGrokRegistrations(runtimePlans).length === 0 ? [] : renderDaimonGrokHostPreflight()),
+        ...(grokRegistrations.length === 0 ? [] : renderDaimonGrokHostPreflight()),
+        // Before broker provisioning: a Grok worker's deny list masks the gateway's paths, which must exist.
+        ...renderDaimonGatewayProvisioning(runtimePlans),
         ...renderDaimonBrokerProvisioning(runtimePlans),
         'if ! getent passwd "$uid" >/dev/null; then',
         '  runtime_identity="daimon-$uid"',
@@ -242,23 +222,21 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
         // organization-uid runtime process below, not the (Grok-only) broker, so
         // this cannot be gated on `resolveDaimonGrokRegistrations`.
         ...renderDaimonUsageLedgerProvisioning(),
-        ...(resolveDaimonGrokRegistrations(runtimePlans).length === 0 ? [] : [
-            ...renderDaimonBrokerSocketWait(),
-            "startup_children=()",
-            "cleanup_broker_startup() { status=$?; trap - EXIT; for child in \"${startup_children[@]}\"; do kill -TERM \"$child\" 2>/dev/null || true; wait \"$child\" 2>/dev/null || true; done; return \"$status\"; }",
-            "trap cleanup_broker_startup EXIT",
-            "trap 'exit 143' TERM INT HUP",
+        ...(grokRegistrations.length === 0 && !gateway ? [] : renderDaimonStartupSupervision()),
+        // The gateway starts first: the broker's readiness probes it for its Grok key.
+        ...renderDaimonGatewayLaunch(runtimePlans, daimonPlan?.runtimeRoot ?? ""),
+        ...(grokRegistrations.length === 0 ? [] : [
             `install -d -o ${DAIMON_BROKER_UID} -g ${DAIMON_BROKER_UID} -m 0700 ${quote(DAIMON_BROKER_REALM)}`,
             `if [ -e ${quote(`${DAIMON_BROKER_REALM}/auth.json`)} ]; then test -f ${quote(`${DAIMON_BROKER_REALM}/auth.json`)} && test ! -L ${quote(`${DAIMON_BROKER_REALM}/auth.json`)}; chown 0:0 ${quote(`${DAIMON_BROKER_REALM}/auth.json`)}; chmod 0600 ${quote(`${DAIMON_BROKER_REALM}/auth.json`)}; chown ${DAIMON_BROKER_UID}:${DAIMON_BROKER_UID} ${quote(`${DAIMON_BROKER_REALM}/auth.json`)}; fi`,
             `setpriv --clear-groups --reuid ${DAIMON_BROKER_UID} --regid ${DAIMON_BROKER_UID} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu 'probe=${DAIMON_BROKER_REALM}/.daimon-ancestry-probe; umask 077; : > "$probe"; rm "$probe"'`,
             `setpriv --clear-groups --reuid ${DAIMON_ORGANIZATION_UID} --regid ${DAIMON_ORGANIZATION_UID} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu '! test -r ${DAIMON_BROKER_REALM}'`,
-            ...resolveDaimonGrokRegistrations(runtimePlans).map((entry) => `setpriv --clear-groups --reuid ${entry.uid} --regid ${entry.uid} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu '! test -r ${DAIMON_BROKER_REALM}'`),
+            ...grokRegistrations.map((entry) => `setpriv --clear-groups --reuid ${entry.uid} --regid ${entry.uid} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu '! test -r ${DAIMON_BROKER_REALM}'`),
             `setpriv --inh-caps=-all --ambient-caps=-all --bounding-set=-all,+chown,+setuid,+setgid -- ${quote(DAIMON_BROKER_EXECUTABLE)} &`,
             "launcher_pid=$!",
             "startup_children+=(\"$launcher_pid\")",
             `wait_for_broker_socket ${quote(DAIMON_BROKER_LAUNCHER_SOCKET)} "$launcher_pid" "engine broker launcher"`,
             `wait_for_broker_identity "$launcher_pid" 0 00000000000000c1 "engine broker launcher"`,
-            `setpriv --clear-groups --reuid ${DAIMON_BROKER_UID} --regid ${DAIMON_BROKER_UID} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- env TMPDIR=${quote(DAIMON_BROKER_TMPDIR)} ${quote(path.posix.join(daimonPlan?.runtimeRoot ?? "", "bin/daimon-runtime"))} engine-broker serve &`,
+            `setpriv --clear-groups --reuid ${DAIMON_BROKER_UID} --regid ${DAIMON_BROKER_UID} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- env TMPDIR=${quote(DAIMON_BROKER_TMPDIR)} ${renderDaimonGatewayRuntimeEnv(runtimePlans)}${quote(path.posix.join(daimonPlan?.runtimeRoot ?? "", "bin/daimon-runtime"))} engine-broker serve &`,
             "broker_pid=$!",
             "startup_children+=(\"$broker_pid\")",
             `wait_for_broker_socket ${quote(DAIMON_BROKER_BACKEND_SOCKET)} "$broker_pid" "engine broker backend"`,
@@ -271,7 +249,7 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
             `[ -S ${quote(DAIMON_BROKER_SOCKET)} ] || exit 1`,
             "for child_spec in \"$launcher_pid:0:00000000000000c1\" \"$relay_pid:2100:0000000000000000\" \"$broker_pid:2100:0000000000000000\"; do child=${child_spec%%:*}; rest=${child_spec#*:}; expected_uid=${rest%%:*}; expected_caps=${rest##*:}; observed_uid=$(awk '/^Uid:/{print $2}' \"/proc/$child/status\"); cap_bnd=$(awk '/^CapBnd:/{print $2}' \"/proc/$child/status\"); [ \"$observed_uid\" = \"$expected_uid\" ] && [ \"$cap_bnd\" = \"$expected_caps\" ] || exit 1; done"
         ]),
-        "setpriv --clear-groups --reuid \"$uid\" --regid \"$gid\" --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu '",
+        `${renderDaimonGatewayRuntimeEnv(runtimePlans)}setpriv --clear-groups --reuid "$uid" --regid "$gid" --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu '`,
         "  if [ \"$EUID\" -eq 0 ]; then exit 1; fi",
         "  test \"$(sed -n \"s/^CapEff:[[:space:]]*//p\" /proc/self/status)\" = 0000000000000000",
         "  exec \"$@\"",
@@ -279,15 +257,17 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
         "runtime_pid=$!",
         "trap - EXIT TERM INT HUP",
         "stopping=0",
-        "stop_children() { stopping=1; kill -TERM \"$runtime_pid\" 2>/dev/null || true; for child in \"${relay_pid:-}\" \"${broker_pid:-}\" \"${launcher_pid:-}\"; do [ -z \"$child\" ] || kill -TERM \"$child\" 2>/dev/null || true; done; }",
+        `stop_children() { stopping=1; kill -TERM "$runtime_pid" 2>/dev/null || true; for child in ${gatewayPid}"\${relay_pid:-}" "\${broker_pid:-}" "\${launcher_pid:-}"; do [ -z "$child" ] || kill -TERM "$child" 2>/dev/null || true; done; }`,
         "trap stop_children TERM INT HUP",
         'watch_pids=("$runtime_pid")',
-        ...(resolveDaimonGrokRegistrations(runtimePlans).length === 0 ? [] : ['watch_pids+=("$relay_pid" "$broker_pid" "$launcher_pid")']),
+        ...(grokRegistrations.length === 0 ? [] : ['watch_pids+=("$relay_pid" "$broker_pid" "$launcher_pid")']),
+        // An external gateway (training sidecar) leaves no local gateway to watch.
+        ...(gateway ? ['[ -z "${gateway_pid:-}" ] || watch_pids+=("$gateway_pid")'] : []),
         "finished_pid=",
         'set +e; wait -n -p finished_pid "${watch_pids[@]}"; status=$?; set -e',
         'if [ "${finished_pid:-}" != "$runtime_pid" ]; then status=1; fi',
         'kill -TERM "$runtime_pid" 2>/dev/null || true',
-        "for child in \"${relay_pid:-}\" \"${broker_pid:-}\" \"${launcher_pid:-}\"; do [ -z \"$child\" ] || { kill -TERM \"$child\" 2>/dev/null || true; wait \"$child\" 2>/dev/null || true; }; done",
+        `for child in "\${relay_pid:-}" "\${broker_pid:-}" "\${launcher_pid:-}"${gatewayPid ? ` ${gatewayPid.trim()}` : ""}; do [ -z "$child" ] || { kill -TERM "$child" 2>/dev/null || true; wait "$child" 2>/dev/null || true; }; done`,
         'wait "$runtime_pid" 2>/dev/null || true',
         "exit \"$status\""
     ].join("\n") + "\n";

package/dist/compiler/containerRuntimeReadinessRender.js

@@ -22,7 +22,7 @@ export const createRuntimeReadinessWait = (plan, pidVariable) => {
             ""
         ];
     }
-    if (!["openclaw", "pi"].includes(plan.runtimeName))
+    if (!["openclaw"].includes(plan.runtimeName))
         return [];
     return [
         "attempts=0",

package/dist/compiler/memoryArtifacts.js

@@ -6,7 +6,6 @@ const createMountId = (mountPath) => `memory-${safeSlug(mountPath)}`;
 const isFileBackedMemoryStore = (bank) => bank.store.kind === "sqlite" || bank.store.kind === "json";
 const transportFromRuntime = (runtimeName, bank) => {
     switch (runtimeName) {
-        case "pi":
         case "daimon":
             // Mneme runs in-process for these runtimes (no MCP subprocess), but
             // whether that in-process runtime is reachable -- and whether it

package/dist/compiler/moltnetArtifacts.js

@@ -1,6 +1,6 @@
 import { resolveNoopolisRunId } from "../runtime/index.js";
 import { createExclusiveReattachVolumeName, SpawnfileError } from "../shared/index.js";
-import { createMoltnetCausalDirectory, createMoltnetDaimonReceiptStorePath, createMoltnetNetworkStateDirectory, createMoltnetServerConfigPath, createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, resolveMoltnetClientAuth, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
+import { createMoltnetCausalDirectory, createMoltnetDaimonReceiptStorePath, createMoltnetNetworkStateDirectory, createMoltnetServerConfigPath, createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
 import { assertNetworkBindingEnvUniqueness } from "./networkBinding.js";
 import { createMoltnetNodeConfigContent } from "./moltnetNodeConfig.js";
 import { createPersistentVolumeName, isNetworkHttpEnabled, toContainerRootfsPath } from "./moltnetArtifactPaths.js";
@@ -152,22 +152,6 @@ export const generateMoltnetArtifacts = async (plan, deploymentLineage = "compil
                 throw new SpawnfileError("validation_error", `Duplicate Moltnet node attachment for ${attachment.network}/${attachment.memberId}`);
             }
             nodePlanKeys.add(nodePlanKey);
-            if (agentNode.runtime.name === "pi") {
-                const clientAuth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, node.slug, attachment.auth?.tokenId);
-                const usesPerAttachmentOpenToken = clientAuth.mode === "open" &&
-                    clientAuth.staticToken !== true &&
-                    Boolean(clientAuth.tokenEnv || clientAuth.tokenPath);
-                if (usesPerAttachmentOpenToken && clientAuth.tokenPath) {
-                    const mountId = `agent-${node.slug}-moltnet-tokens`;
-                    addPersistentMount({
-                        id: mountId,
-                        lifecycle: "exclusive-reattach",
-                        mountPath: createMoltnetOpenTokenDirectory(node.slug),
-                        reason: `Moltnet open-mode generated agent tokens for ${agentNode.name}`,
-                        volumeName: durableVolumeName(mountId)
-                    });
-                }
-            }
             const nodeConfig = createMoltnetNodeConfigContent({
                 agentNode,
                 attachment: { ...attachment, memberId: attachment.memberId },

package/dist/compiler/moltnetClientConfig.js

@@ -68,7 +68,7 @@ const createAttachmentConfig = (node, artifacts, attachment, agentSlug) => {
     };
 };
 export const resolveMoltnetWorkspaceLayout = (runtimeName, _agentName) => {
-    if (runtimeName === "daimon" || runtimeName === "pi") {
+    if (runtimeName === "daimon") {
         return {
             clientConfigPath: `workspace/.moltnet/config.json`,
             cliRuntime: "codex",

package/dist/compiler/moltnetRuntimeConfig.js

@@ -72,16 +72,6 @@ export const resolveRuntimeConfig = (plan, agentNode, nodeSlug, networkId, moltn
                 token_env: "SPAWNFILE_DAIMON_CONTROL_TOKEN"
             };
         }
-        case "pi": {
-            const port = getRuntimeAdapter(agentNode.runtime.name).container.port;
-            if (!port) {
-                throw new SpawnfileError("compile_error", `Unable to resolve ${agentNode.runtime.name} control port for Moltnet agent ${agentNode.name}`);
-            }
-            return {
-                control_url: `http://127.0.0.1:${port}/agents/${nodeSlug}/wake`,
-                kind: "pi"
-            };
-        }
         default:
             throw new SpawnfileError("compile_error", `Moltnet does not know how to attach runtime ${agentNode.runtime.name} directly`);
     }

package/dist/compiler/runProject.d.ts

@@ -38,6 +38,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
     dockerContext?: string;
     dockerHost?: string;
     envFilePath?: string;
+    network?: string;
 }) => Promise<DockerRunInvocation>;
 interface ResolvedRunDeploymentOptions {
     previousRecord?: DeploymentRecord;

package/dist/compiler/runProject.js

@@ -6,6 +6,7 @@ import { ensureDirectory, fileExists, removeDirectory, writeUtf8File } from "../
 import { appendDockerLabelArgs, createDockerDeploymentLabels, createDockerDeploymentUnitId, createDockerProjectLabel, dockerContextNameForTarget, dockerHostValueForTarget, normalizeDeploymentName, readDeploymentRecordFromOutput, resolveDeploymentRecordPath, verifyDockerDeploymentTarget, writeDockerDeploymentRecordForRun } from "../deployment/index.js";
 import { DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
 import { ensureNoopolisRunId, resolveNoopolisRunId } from "../runtime/index.js";
+import { DAIMON_GATEWAY_URL_ENV, isDaimonGatewayRealmMountId } from "../runtime/daimon/index.js";
 import { compileProject } from "./compileProject.js";
 import { createDefaultImageTag, resolveDockerBuildArchitecture } from "./buildProject.js";
 import { slugify } from "./helpers.js";
@@ -62,6 +63,8 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             args.push("--rm");
         }
         args.push("--name", containerName);
+        if (options.network)
+            args.push("--network", options.network);
         if (hasDaimon) {
             args.push(...DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, ...(await resolveDaimonCodexNativeSandboxDockerSecurityOptions(compileResult)));
         }
@@ -80,7 +83,10 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
         // reattached volume that already holds state is untouched by dropping it.
         // (Target/secrets volumes under src/target/* keep `volume-nocopy`: no
         // image content backs those paths and they must stay opaque.)
-        for (const mount of containerReport.persistent_mounts ?? []) {
+        // An external auth gateway in the run env holds every gatewayed realm; the org mounts none.
+        const persistentMounts = (containerReport.persistent_mounts ?? [])
+            .filter((mount) => !env[DAIMON_GATEWAY_URL_ENV] || !isDaimonGatewayRealmMountId(mount.id));
+        for (const mount of persistentMounts) {
             args.push("--mount", `type=volume,source=${mount.volume_name},target=${mount.mount_path}`);
         }
         const deploymentLabels = options.detach && deploymentName ? (() => {
@@ -109,8 +115,8 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             dockerContext: options.dockerContext ?? null,
             dockerHost: options.dockerHost ?? null,
             envFilePath,
-            ...((containerReport.persistent_mounts ?? []).some((mount) => mount.lifecycle === "exclusive-reattach") ? {
-                exclusiveReattachVolumes: (containerReport.persistent_mounts ?? [])
+            ...(persistentMounts.some((mount) => mount.lifecycle === "exclusive-reattach") ? {
+                exclusiveReattachVolumes: persistentMounts
                     .filter((mount) => mount.lifecycle === "exclusive-reattach")
                     .map((mount) => mount.volume_name)
                     .sort()

package/dist/compiler/runProjectAuth.js

@@ -46,13 +46,7 @@ const addCoveredModelSecrets = (coveredModelSecrets, instanceId, secretNames) =>
     }
 };
 export const prepareRuntimeAuthMounts = async (outputDirectory, containerReport, authProfile, env, tempRoot, containerCredentialUid) => {
-    // No early return when `authProfile` is null: an adapter's
-    // `prepareRuntimeAuth` may still have host-credential staging to do that
-    // does not depend on an imported Spawnfile auth profile (e.g. the Pi
-    // adapter mounting the host's `~/.grok`/`~/.codex`/antigravity CLI homes
-    // for a real-engine org — see `src/runtime/pi/runAuth.ts`). Each adapter is
-    // responsible for treating a `null` `authProfile` as "no profile-derived
-    // imports available" rather than failing.
+    // Adapters receive null profiles so they can handle runtime-owned credentials.
     const coveredModelSecrets = new Set();
     let launchIdentity;
     const mountArgs = [];
@@ -227,15 +221,6 @@ export const resolveAuthMountArgs = async (containerReport, authProfile) => {
         return [];
     }
     const args = [];
-    // Pi owns its model and CLI-engine auth projection in preparePiRuntimeAuth.
-    // Mounting the generic imported home onto the same destination would create
-    // duplicate Docker mount points and bypass the adapter's minimal-file staging.
-    const piRuntimeHomes = new Set(containerReport.runtime_instances
-        .filter((instance) => instance.runtime === "pi")
-        .map((instance) => instance.home_path)
-        .filter((homePath) => homePath !== null));
-    const genericRuntimeHomes = containerReport.runtime_homes
-        .filter((runtimeHome) => !piRuntimeHomes.has(runtimeHome));
     for (const [kind, entry] of Object.entries(authProfile.imports)) {
         if (!entry) {
             continue;
@@ -243,7 +228,7 @@ export const resolveAuthMountArgs = async (containerReport, authProfile) => {
         if (!(await fileExists(entry.path))) {
             throw new SpawnfileError("validation_error", `Imported auth path for ${kind} does not exist: ${entry.path}`);
         }
-        for (const runtimeHome of genericRuntimeHomes) {
+        for (const runtimeHome of containerReport.runtime_homes) {
             args.push("-v", `${entry.path}:${path.posix.join(runtimeHome, getImportMountTargetName(kind))}`);
         }
     }

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

@@ -1,7 +1,5 @@
 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;

package/dist/compiler/training/contract.js

@@ -1,7 +1,5 @@
 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);

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

@@ -1,8 +1,6 @@
 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/spawnfile-training/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<{
@@ -151,10 +149,8 @@ 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. */
+/** Resolve authoring defaults into training CLI arguments; no writes, auth reads or execution. */
 export declare const lowerTrainingExecution: (options: LowerTrainingExecutionOptions) => Promise<{
     execution: {
         version: "spawnfile.training-execution.v1";
@@ -287,129 +283,6 @@ export declare const lowerTrainingExecution: (options: LowerTrainingExecutionOpt
         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";
-                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;
-    };
 }>;
 /** 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;

package/dist/compiler/training/execution.js

@@ -5,11 +5,6 @@ import { z } from "zod";
 import { defaultTrainingOutputRoot } from "./output.js";
 import { SpawnfileError } from "../../shared/index.js";
 import { trainingPlanSchema, trainingPlanOptimizerSchema } from "./plan/contract.js";
-import { trainingPreparationSchema } from "./preparation/contract.js";
-import { readBoundedJson } from "./preparation/inputs.js";
-import { trainingContainerConfigSchema, trainingImageSchema } from "./container/contract.js";
-export const TRAINING_EXECUTION_FILE = "/run/spawnfile-training/execution.json";
-export { TRAINING_EXECUTION_CAPABILITY_LABEL, TRAINING_EXECUTION_VERSION } from "./contract.js";
 export const trainingExecutionSchema = z.object({
     version: z.literal("spawnfile.training-execution.v1"),
     authoring: trainingPlanSchema,
@@ -34,32 +29,11 @@ const exists = async (file) => {
         throw error;
     }
 };
-/** Resolve local declaration and authoring defaults; no writes, auth reads or execution. */
+/** Resolve authoring defaults into training CLI arguments; no writes, auth reads or execution. */
 export const lowerTrainingExecution = async (options) => {
     const { project, plan } = options;
     if (!plan.targets.length || !plan.optimizer)
         return invalid(`Agent ${plan.agent.id} has no executable training targets`);
-    const agent = project.compilePlan.nodes.find(node => node.id === plan.agent.id);
-    const agentDirectory = path.dirname(agent.value.kind === "agent" ? agent.value.sourcePath ?? agent.value.source : agent.value.source);
-    const candidates = [...new Set([agentDirectory, project.root].map(root => path.join(root, "training/container.json")))];
-    let trainingConfig = options.trainingConfig === undefined ? undefined : path.resolve(options.trainingConfig);
-    if (trainingConfig === undefined)
-        for (const file of candidates)
-            if (await exists(file)) {
-                trainingConfig = file;
-                break;
-            }
-    if (trainingConfig === undefined)
-        return invalid(`Training requires a container declaration at ${candidates.join(" or ")}, or --training-config`);
-    trainingConfig = await realpath(trainingConfig);
-    const raw = await readBoundedJson(trainingConfig);
-    const preparation = raw.version === "spawnfile.training-container.v2" ||
-        (["spawnfile.training-container.v3", "spawnfile.training-container.v4"].includes(String(raw.version)) && raw.image !== undefined);
-    const declaration = preparation ? trainingPreparationSchema.parse(raw) : trainingContainerConfigSchema.parse(raw);
-    const trainingImage = options.trainingImage === undefined ? undefined : trainingImageSchema.parse(options.trainingImage);
-    if (!preparation && trainingImage === undefined) {
-        return invalid("A lowered container launch configuration requires --training-image; use a v2/v4 preparation declaration for a declared image");
-    }
     const args = [...options.args];
     if (!args.includes("--experiment-timeout-ms") && !args.includes("--timeout-ms")) {
         args.push("--experiment-timeout-ms", String(plan.deadlines?.experiment_ms ?? 43_200_000));
@@ -84,11 +58,6 @@ export const lowerTrainingExecution = async (options) => {
         args.push("--optimizer-model", plan.optimizer.model);
     if (args.includes("--resume") && option(args, "--out") === undefined)
         return invalid("--resume requires --out identifying the exact prior experiment");
-    const output = path.resolve(option(args, "--out") ?? path.join(defaultTrainingOutputRoot(project.root, declaration.inputs.map(input => path.resolve(path.dirname(trainingConfig), input.source))), encodeURIComponent(plan.agent.id), `${new Date().toISOString().replace(/[:.]/gu, "-")}-${randomUUID().slice(0, 8)}`));
-    if (!args.includes("--out"))
-        args.push("--out", output);
-    else
-        args[args.indexOf("--out") + 1] = output;
     const datasetPins = [...new Set(plan.targets.flatMap(target => Object.values(target.datasets)
             .filter(dataset => dataset !== null).map(dataset => dataset.sourcePath)))].map(sourcePath => {
         const loaded = project.datasets[sourcePath];
@@ -96,9 +65,14 @@ export const lowerTrainingExecution = async (options) => {
             return invalid(`Authored dataset was not captured during plan loading: ${sourcePath}`);
         return { sourcePath, sha256: loaded.sha256 };
     });
+    const output = path.resolve(option(args, "--out") ?? path.join(defaultTrainingOutputRoot(project.root, datasetPins.map(pin => pin.sourcePath)), encodeURIComponent(plan.agent.id), `${new Date().toISOString().replace(/[:.]/gu, "-")}-${randomUUID().slice(0, 8)}`));
+    if (!args.includes("--out"))
+        args.push("--out", output);
+    else
+        args[args.indexOf("--out") + 1] = output;
     const execution = trainingExecutionSchema.parse({ version: "spawnfile.training-execution.v1", authoring: plan, datasetPins,
         optimizer: { ...plan.optimizer, model: option(args, "--optimizer-model") }, args, output });
-    return { execution, trainingConfig, trainingImage, declaration };
+    return { execution };
 };
 /** Allocation is separate so dry-run never creates a directory, and aliases fail before writes. */
 export const allocateTrainingOutputParent = async (output) => {
@@ -123,38 +97,3 @@ export const allocateTrainingOutputParent = async (output) => {
             invalid("Training output parent must be a canonical directory");
     }
 };
-/** Preserve identities and all dataset roles while projecting only filesystem addresses. */
-export const mapTrainingExecution = (execution, map) => {
-    const source = (value) => ({ ...value, sourcePath: map(value.sourcePath) });
-    const args = [...execution.args];
-    for (let index = 0; index < args.length; index++) {
-        if (["--train", "--validation", "--test", "--out", "--cost-config"].includes(args[index]))
-            args[++index] = map(args[index]);
-        else if (args[index] === "--resource") {
-            const value = args[++index], split = value.indexOf("=");
-            args[index] = `${value.slice(0, split)}=${map(value.slice(split + 1))}`;
-        }
-    }
-    return trainingExecutionSchema.parse({ ...execution, datasetPins: execution.datasetPins.map(source), args, output: map(execution.output), authoring: {
-            ...execution.authoring,
-            ...(execution.authoring.preparation ? { preparation: { ...execution.authoring.preparation,
-                    ...(execution.authoring.preparation.history ? { history: map(execution.authoring.preparation.history) } : {}) } } : {}),
-            project: { root: map(execution.authoring.project.root), manifest: map(execution.authoring.project.manifest) },
-            graders: execution.authoring.graders.map(source),
-            targets: execution.authoring.targets.map(target => ({ ...target, files: target.files.map(source), datasets: {
-                    train: source(target.datasets.train), test: source(target.datasets.test),
-                    validation: target.datasets.validation === null ? null : source(target.datasets.validation)
-                } }))
-        } });
-};
-/** Resume changes position/presence of --resume, not the experiment's effective inputs. */
-export const trainingExecutionIdentity = (execution) => {
-    const flags = [];
-    for (let index = 0; index < execution.args.length; index++) {
-        const flag = execution.args[index];
-        if (flag === "--resume")
-            continue;
-        flags.push(flag === "--dry-run" ? [flag] : [flag, execution.args[++index]]);
-    }
-    return { ...execution, args: flags.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0) };
-};

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

@@ -3,14 +3,6 @@ export * from "./context.js";
 export * from "./plan/index.js";
 export * from "./rewind/index.js";
 export type { ResolvedTraining, ResolvedTrainingGrader } from "./resolution.js";
-export { parseTrainingMappedPreparation, trainingPreparationSchema } from "./preparation/contract.js";
-export { prepareTrainingEvaluators } from "./container/evaluators.js";
-export type { TrainingMappedPreparation } from "./preparation/contract.js";
-export { TRAINING_SLOTS_FILE, TRAINING_SLOTS_VERSION, trainingSlotPaths, trainingSlotDescriptors, trainingSlotsDocument, type TrainingSlotsDocument, type TrainingSlotPaths, type TrainingSlotDescriptor } from "./broker/paths.js";
 export * from "./execution.js";
 export * from "./moments.js";
 export * from "./compiledAgent.js";
-export { TRAINING_FAKETIME_LIBRARY_PATH } from "./container/contract.js";
-export * from "./subjectLease.js";
-export * from "./subjectDeclaration.js";
-export { recycleTrainingSlot, type RecycleTrainingSlotOptions, type TrainingSlotRecycleReceipt } from "./broker/recycleClient.js";