spawnfile 0.1.33 → 0.1.35

package/dist/compiler/containerDaimonGrokWorkerRender.d.ts

@@ -49,8 +49,6 @@ export interface DaimonGrokRegistration {
     agentId: string;
     config: string;
     configSha256: string;
-    /** Selects trusted config bytes; production retains the unclocked default. */
-    configVariant?: "unclocked" | "clocked";
     denyPaths: string[];
     /** Deny entries the main entrypoint materializes after root provisioning (workspace resource backings); absent is allowed there, a symlink never. */
     deferredDenyPaths: string[];
@@ -138,26 +136,20 @@ export declare const DAIMON_GROK_DENIED_STATE_ROOTS: readonly ["/var/lib/spawnfi
  */
 export declare const resolveDaimonGrokWorkerDenyPaths: (plans: readonly RuntimeTargetPlan[], plan: RuntimeTargetPlan, agentId: string, workerHomes: readonly string[], ownHome: string) => string[];
 export declare const resolveDaimonGrokRegistrations: (plans: RuntimeTargetPlan[]) => DaimonGrokRegistration[];
-export interface DaimonGrokServiceConfigOptions {
-    /** Repeated agent IDs use v3 slot policies; production retains v2 by default. */
-    version?: "v3";
-    maxRunRequests?: number;
-    runRequestStore?: string;
-    /**
-     * Where the broker keeps its durable turn registry. Production keeps it on
-     * the realm volume beside the credential; training overrides it to per-slot
-     * tmpfs so a recycled slot can never replay trial N's sealed turn in trial
-     * N+1 (R2), and refuses any path on the realm volume for that reason.
-     */
-    turnStore?: string;
-    /** `service.json` v2's optional evaluator inference ledger. Without it the broker refuses every grant. */
-    inferenceLedgerPath?: string;
-}
 /** `service.json` v2, exactly the shape Daimon's strict `parseEngineBrokerServiceConfig` accepts. */
-export declare const renderDaimonGrokServiceConfig: (registrations: readonly DaimonGrokRegistration[], options?: DaimonGrokServiceConfigOptions) => {
-    slotPolicies?: {
+export declare const renderDaimonGrokServiceConfig: (registrations: readonly DaimonGrokRegistration[]) => {
+    version: "noopolis.daimon.engine-broker-service.v2";
+    credentialHome: "/var/lib/spawnfile/daimon/grok-subscription-realm";
+    turnStore: "/var/lib/spawnfile/daimon/grok-subscription-realm/turns";
+    registrations: {
         skillsSha256?: string | undefined;
+        agentId: string;
         slot: number;
+        workerUid: number;
+        workspace: string;
+        profilePath: string;
+        eventsPath: string;
+        profileSha256: string;
         usageLedgerPath: string;
         limits: {
             maxRequests: 32;
@@ -172,35 +164,5 @@ export declare const renderDaimonGrokServiceConfig: (registrations: readonly Dai
             id: "grok-4.6" | "grok-4.5" | "grok-build";
             reasoningEffort: "low" | "medium" | "high";
         };
-    }[] | undefined;
-    registrations: {
-        skillsSha256?: string | undefined;
-        usageLedgerPath?: string | undefined;
-        limits?: {
-            maxRequests: 32;
-            maxTokens: 300000;
-            timeoutMs: 240000;
-        } | {
-            maxRequests: number;
-            maxTokens: number;
-            timeoutMs: number;
-        } | undefined;
-        model?: {
-            id: "grok-4.6" | "grok-4.5" | "grok-build";
-            reasoningEffort: "low" | "medium" | "high";
-        } | undefined;
-        agentId: string;
-        slot: number;
-        workerUid: number;
-        workspace: string;
-        profilePath: string;
-        eventsPath: string;
-        profileSha256: string;
     }[];
-    inferenceLedgerPath?: string | undefined;
-    runRequestStore?: string | undefined;
-    maxRunRequests?: number | undefined;
-    version: "noopolis.daimon.engine-broker-service.v2" | "noopolis.daimon.engine-broker-service.v3";
-    credentialHome: "/var/lib/spawnfile/daimon/grok-subscription-realm";
-    turnStore: string;
 };

package/dist/compiler/containerDaimonGrokWorkerRender.js

@@ -1,3 +1,4 @@
+import { DAIMON_GATEWAY_BOOTSTRAP_ROOT, DAIMON_GATEWAY_ETC, DAIMON_GATEWAY_RUN, daimonGatewayRealmPath, isDaimonGatewayedEngine } from "../runtime/daimon/gateway.js";
 import { daimonEngineHasBroker, getDaimonEngineDescriptor } from "../runtime/daimon/index.js";
 import path from "node:path";
 import { SpawnfileError } from "../shared/index.js";
@@ -125,10 +126,13 @@ export const resolveDaimonGrokWorkerDenyPaths = (plans, plan, agentId, workerHom
     const peers = agents.filter(([id]) => id !== agentId).map(([id]) => nodeSlug(id));
     const daimonOwn = [
         ...[...new Set(agents.map(([, engine]) => engine))].flatMap((engine) => {
-            const auth = getDaimonEngineDescriptor(engine)?.auth;
-            return auth?.staging === "portable-realm" ? [auth.realm.bootstrapMountPath, auth.realm.durableMountPath] : [];
+            const descriptor = getDaimonEngineDescriptor(engine);
+            // A gatewayed bootstrap leaf sits under the root-only gateway root; mask that root, the realm and the gateway's state.
+            return isDaimonGatewayedEngine(descriptor)
+                ? [DAIMON_GATEWAY_BOOTSTRAP_ROOT, daimonGatewayRealmPath(descriptor), DAIMON_GATEWAY_ETC, DAIMON_GATEWAY_RUN]
+                : [];
         }),
-        DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath,
+        // The broker's local turn-state home (it holds no credential in gateway mode).
         DAIMON_GROK_SUBSCRIPTION_REALM.durableMountPath,
         ...(agents.some(([, engine]) => getDaimonEngineDescriptor(engine)?.auth.staging === "secret-service") ? [DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath, DAIMON_AGY_SUBSCRIPTION_REALM.durableMountPath] : []),
         daimonGrokAcceptanceStoreDenyPath(instanceRoot),
@@ -242,33 +246,11 @@ export const resolveDaimonGrokRegistrations = (plans) => {
         };
     });
 };
-const resolveDaimonGrokTurnStore = (turnStore) => {
-    if (turnStore === undefined)
-        return DAIMON_GROK_ENGINE_BROKER.turnStorePath;
-    assertCanonicalRegisteredPath("turn store", turnStore);
-    if (turnStore === DAIMON_GROK_SUBSCRIPTION_REALM.durableMountPath || turnStore.startsWith(`${DAIMON_GROK_SUBSCRIPTION_REALM.durableMountPath}/`)) {
-        fail(`Grok broker turn store ${turnStore} is on the durable credential realm; a recycled slot would replay the previous trial's sealed turns`);
-    }
-    return turnStore;
-};
-const resolveDaimonGrokInferenceLedger = (inferenceLedgerPath, registrations) => {
-    assertCanonicalRegisteredPath("inference ledger", inferenceLedgerPath);
-    if (!inferenceLedgerPath.endsWith(".jsonl"))
-        fail(`Grok inference ledger must be a .jsonl path: ${inferenceLedgerPath}`);
-    const subject = new Set([DAIMON_GROK_TURN_USAGE_LEDGER.filePath, path.posix.join(DAIMON_GROK_TURN_USAGE_LEDGER.directoryPath, "requests.jsonl"),
-        ...registrations.flatMap((entry) => [entry.usageLedgerPath, path.posix.join(path.posix.dirname(entry.usageLedgerPath), "requests.jsonl")])]);
-    if (subject.has(inferenceLedgerPath))
-        fail(`Grok inference ledger ${inferenceLedgerPath} is a subject usage ledger; judge spend must never reach the wake fuse`);
-    return inferenceLedgerPath;
-};
 /** `service.json` v2, exactly the shape Daimon's strict `parseEngineBrokerServiceConfig` accepts. */
-export const renderDaimonGrokServiceConfig = (registrations, options = {}) => ({
-    version: DAIMON_GROK_ENGINE_BROKER.serviceConfigVersions[options.version === "v3" ? 2 : 1],
+export const renderDaimonGrokServiceConfig = (registrations) => ({
+    version: DAIMON_GROK_ENGINE_BROKER.serviceConfigVersions[1],
     credentialHome: DAIMON_GROK_ENGINE_BROKER.credentialHomePath,
-    turnStore: resolveDaimonGrokTurnStore(options.turnStore),
-    ...(options.maxRunRequests === undefined ? {} : { maxRunRequests: options.maxRunRequests }),
-    ...(options.runRequestStore === undefined ? {} : { runRequestStore: assertCanonicalRegisteredPath("run request store", options.runRequestStore) }),
-    ...(options.inferenceLedgerPath === undefined ? {} : { inferenceLedgerPath: resolveDaimonGrokInferenceLedger(options.inferenceLedgerPath, registrations) }),
+    turnStore: DAIMON_GROK_ENGINE_BROKER.turnStorePath,
     registrations: registrations.map((entry) => ({
         agentId: entry.agentId,
         slot: entry.slot,
@@ -277,15 +259,9 @@ export const renderDaimonGrokServiceConfig = (registrations, options = {}) => ({
         profilePath: entry.profilePath,
         eventsPath: entry.eventsPath,
         profileSha256: entry.profileSha256,
-        ...(options.version === "v3" ? {} : { usageLedgerPath: entry.usageLedgerPath,
-            limits: { ...(entry.limits ?? DAIMON_GROK_ENGINE_BROKER.turnLimits.v1Defaults) },
-            model: { id: entry.model, reasoningEffort: entry.reasoningEffort },
-            ...(entry.skills ? { skillsSha256: entry.skills.sha256 } : {}) })
-    })),
-    ...(options.version === "v3" ? { slotPolicies: registrations.map(entry => ({
-            slot: entry.slot, usageLedgerPath: entry.usageLedgerPath,
-            limits: { ...(entry.limits ?? DAIMON_GROK_ENGINE_BROKER.turnLimits.v1Defaults) },
-            model: { id: entry.model, reasoningEffort: entry.reasoningEffort },
-            ...(entry.skills ? { skillsSha256: entry.skills.sha256 } : {})
-        })) } : {})
+        usageLedgerPath: entry.usageLedgerPath,
+        limits: { ...(entry.limits ?? DAIMON_GROK_ENGINE_BROKER.turnLimits.v1Defaults) },
+        model: { id: entry.model, reasoningEffort: entry.reasoningEffort },
+        ...(entry.skills ? { skillsSha256: entry.skills.sha256 } : {})
+    }))
 });

package/dist/compiler/containerDaimonStartupSupervision.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Root-side supervision for the privileged startup children (engine broker,
+ * relay, launcher and auth gateway): bounded readiness waits plus one EXIT
+ * trap that terminates every started child if startup fails.
+ */
+export declare const DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS = 60;
+export declare const renderDaimonBrokerSocketWait: (timeoutSeconds?: number, pollSeconds?: number) => string[];
+export declare const renderDaimonStartupSupervision: () => string[];

package/dist/compiler/containerDaimonStartupSupervision.js

@@ -0,0 +1,39 @@
+/**
+ * Root-side supervision for the privileged startup children (engine broker,
+ * relay, launcher and auth gateway): bounded readiness waits plus one EXIT
+ * trap that terminates every started child if startup fails.
+ */
+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",
+    "}"
+];
+export const renderDaimonStartupSupervision = () => [
+    ...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"
+];

package/dist/compiler/containerDaimonUidEntrypointRender.d.ts

@@ -2,12 +2,11 @@ import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
 import type { EntrypointOptions } from "./containerEntrypointRender.js";
 import { type BackedMountRequirement } from "./containerBackedMountRender.js";
 export { resolveDaimonVolumeIdentityFiles } from "./containerDaimonOwnershipGuardRender.js";
+export { DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS, renderDaimonBrokerSocketWait } from "./containerDaimonStartupSupervision.js";
 export declare const DAIMON_AUTHORIZED_UID_ENV = "SPAWNFILE_DAIMON_AUTHORIZED_UID";
 export declare const DAIMON_RUNTIME_UID = 2000;
 export declare const DAIMON_UID_ENTRYPOINT_PATH = "/opt/spawnfile/daimon-uid-entrypoint.sh";
 export declare const DAIMON_RUNTIME_HOMES_DIRECTORY = "runtime-homes";
-export declare const DAIMON_BROKER_STARTUP_TIMEOUT_SECONDS = 60;
-export declare const renderDaimonBrokerSocketWait: (timeoutSeconds?: number, pollSeconds?: number) => string[];
 export declare const resolveDaimonUidEntrypointStateRoots: (runtimePlans: RuntimeTargetPlan[]) => string[];
 export interface DaimonUidEntrypointOwnershipPlan {
     creatablePrivateDirectories: Array<{

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,23 +249,27 @@ 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 \"$@\"",
-        `' bash "\${runtime_command[@]}" &`,
+        // Explicit stdin: a non-interactive shell gives `&` jobs /dev/null, which would
+        // starve the interactive `auth <engine> login` of the operator's terminal.
+        `' bash "\${runtime_command[@]}" <&0 &`,
         "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

@@ -29,6 +29,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
         name: string;
         value: string;
     };
+    command?: readonly string[];
     /** See `RuntimeAuthPreparationInput.containerCredentialUid`. */
     containerCredentialUid?: number;
     containerName?: string;
@@ -38,6 +39,8 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
     dockerContext?: string;
     dockerHost?: string;
     envFilePath?: string;
+    interactive?: boolean;
+    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, daimonProfileRealmVolume, isDaimonGatewayRealmMountId } from "../runtime/daimon/index.js";
 import { compileProject } from "./compileProject.js";
 import { createDefaultImageTag, resolveDockerBuildArchitecture } from "./buildProject.js";
 import { slugify } from "./helpers.js";
@@ -59,9 +60,11 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             args.push("-d", "--restart", "unless-stopped");
         }
         else {
-            args.push("--rm");
+            args.push("--rm", ...(options.interactive ? ["-it"] : []));
         }
         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,11 @@ 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 holds every gatewayed realm (the org mounts none); a profile-held login reattaches its volume.
+        const persistentMounts = (containerReport.persistent_mounts ?? [])
+            .filter((mount) => !env[DAIMON_GATEWAY_URL_ENV] || !isDaimonGatewayRealmMountId(mount.id))
+            .map((mount) => ({ ...mount, volume_name: daimonProfileRealmVolume(mount.id, options.authProfile) ?? mount.volume_name }));
+        for (const mount of persistentMounts) {
             args.push("--mount", `type=volume,source=${mount.volume_name},target=${mount.mount_path}`);
         }
         const deploymentLabels = options.detach && deploymentName ? (() => {
@@ -97,7 +104,7 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
         args.push("--env-file", envFilePath);
         args.push(...(await resolveAuthMountArgs(containerReport, options.authProfile ?? null)));
         args.push(...preparedRuntimeAuth.mountArgs);
-        args.push(imageTag);
+        args.push(imageTag, ...(options.command ?? []));
         return {
             args,
             command: options.dockerCommand ?? "docker",
@@ -109,8 +116,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 = [];
@@ -113,6 +107,7 @@ export const assertDeclaredModelAuthSatisfied = (containerReport, authProfile, c
         throw new SpawnfileError("validation_error", `Auth profile ${authProfile.name} is missing required auth imports: ${missingImportKinds.join(", ")}`);
     }
 };
+const RUNTIME_HOME_IMPORT_KINDS = ["claude-code", "codex"];
 const getImportMountTargetName = (kind) => kind === "claude-code" ? ".claude" : ".codex";
 const createGeneratedRuntimeSecret = (secretName, generatedMoltnetSecrets) => {
     if (secretName === "OPENCLAW_GATEWAY_TOKEN" || secretName === "OPENCLAW_HOOKS_TOKEN") {
@@ -227,23 +222,16 @@ 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)) {
+    // Only runtime-home logins are bind-mounted; a Grok import belongs to the auth gateway alone.
+    for (const kind of RUNTIME_HOME_IMPORT_KINDS) {
+        const entry = authProfile.imports[kind];
         if (!entry) {
             continue;
         }
         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);