spawnfile 0.1.33 → 0.1.35

package/dist/release/drainControl.d.ts

@@ -1,24 +1,10 @@
-/**
- * The running organization's control plane, reached the way every other
- * Spawnfile probe reaches a container's loopback: an ephemeral helper from the
- * same image inside the target's network namespace. The bearer token goes to
- * curl on stdin (`-H @-`), never on a command line another host process could
- * read.
- */
-export interface RuntimeControlTarget {
-    containerRef: string;
-    dockerArgs: readonly string[];
-    dockerCommand: string;
-    imageRef: string;
-    token: string;
-}
-export interface ControlResponse {
-    body: string;
-    status: number;
-}
+import { type DaimonControlResponse, type DaimonControlTarget } from "../runtime/daimon/control.js";
+/** The running organization's control plane, through the shared Daimon control client. */
+export type RuntimeControlTarget = DaimonControlTarget;
+export type ControlResponse = DaimonControlResponse;
 export type ControlCall = (target: RuntimeControlTarget, method: "GET" | "POST", route: string) => Promise<ControlResponse>;
 export declare const CONTROL_CALL_TIMEOUT_MS = 60000;
-export declare const controlHelperArgs: (target: RuntimeControlTarget, method: "GET" | "POST", route: string) => string[];
+export declare const controlHelperArgs: (target: DaimonControlTarget, method: import("../runtime/daimon/control.js").DaimonControlMethod, route: string) => string[];
 export declare const parseHelperOutput: (stdout: string) => ControlResponse;
 export declare const helperControlCall: ControlCall;
 export type DrainState = "draining" | "drained" | null;

package/dist/release/drainControl.js

@@ -1,74 +1,19 @@
-import { spawn } from "node:child_process";
-import { DAIMON_CONTROL_PORT } from "../runtime/daimon/config.js";
+import { DAIMON_CONTROL_CALL_TIMEOUT_MS, DaimonControlError, daimonControlHelperArgs, daimonHelperControlCall, parseDaimonControlHelperOutput } from "../runtime/daimon/control.js";
 import { ReleaseError } from "./types.js";
-export const CONTROL_CALL_TIMEOUT_MS = 60_000;
-const MAX_CONTROL_OUTPUT_BYTES = 1024 * 1024;
-export const controlHelperArgs = (target, method, route) => [
-    ...target.dockerArgs,
-    "run", "--rm", "-i", "--pull", "never",
-    "--network", `container:${target.containerRef}`,
-    "--entrypoint", "curl",
-    target.imageRef,
-    "-sS", "--max-time", "15", "-X", method, "-H", "@-",
-    "--output", "-", "--write-out", "\\n%{http_code}",
-    `http://127.0.0.1:${DAIMON_CONTROL_PORT}${route}`
-];
-const redact = (text, token) => (token ? text.split(token).join("[redacted]") : text).replace(/\s+/gu, " ").slice(0, 240);
+export const CONTROL_CALL_TIMEOUT_MS = DAIMON_CONTROL_CALL_TIMEOUT_MS;
+export const controlHelperArgs = daimonControlHelperArgs;
+const asRelease = (error) => {
+    throw error instanceof DaimonControlError ? new ReleaseError("drain-failed", error.message) : error;
+};
 export const parseHelperOutput = (stdout) => {
-    const match = /\n(\d{3})$/u.exec(stdout);
-    if (!match || match.index === undefined) {
-        throw new ReleaseError("drain-failed", "the runtime control helper returned no HTTP status");
+    try {
+        return parseDaimonControlHelperOutput(stdout);
+    }
+    catch (error) {
+        return asRelease(error);
     }
-    return { body: stdout.slice(0, match.index), status: Number(match[1]) };
 };
-export const helperControlCall = (target, method, route) => new Promise((resolve, reject) => {
-    const child = spawn(target.dockerCommand, controlHelperArgs(target, method, route), {
-        stdio: ["pipe", "pipe", "pipe"]
-    });
-    const out = [];
-    let bytes = 0;
-    let stderr = "";
-    let settled = false;
-    const finish = (error, value) => {
-        if (settled)
-            return;
-        settled = true;
-        clearTimeout(timer);
-        if (error)
-            reject(error);
-        else
-            resolve(value);
-    };
-    const timer = setTimeout(() => {
-        child.kill("SIGKILL");
-        finish(new ReleaseError("drain-failed", `runtime control ${method} ${route} timed out`));
-    }, CONTROL_CALL_TIMEOUT_MS);
-    child.stdout.on("data", (chunk) => {
-        bytes += chunk.length;
-        if (bytes > MAX_CONTROL_OUTPUT_BYTES) {
-            child.kill("SIGKILL");
-            finish(new ReleaseError("drain-failed", `runtime control ${method} ${route} answered more than the output bound`));
-            return;
-        }
-        out.push(chunk);
-    });
-    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk.toString("utf8")}`.slice(-2000); });
-    child.once("error", (error) => finish(new ReleaseError("drain-failed", `cannot start the runtime control helper: ${error.message}`)));
-    child.once("close", (code) => {
-        if (code !== 0) {
-            finish(new ReleaseError("drain-failed", `runtime control ${method} ${route} failed (exit ${code ?? "signal"}): ${redact(stderr, target.token)}`));
-            return;
-        }
-        try {
-            finish(null, parseHelperOutput(Buffer.concat(out).toString("utf8")));
-        }
-        catch (error) {
-            finish(error);
-        }
-    });
-    child.stdin.on("error", () => undefined);
-    child.stdin.end(`Authorization: Bearer ${target.token}\n`);
-});
+export const helperControlCall = (target, method, route) => daimonHelperControlCall(target, method, route).catch(asRelease);
 /** The parts of `noopolis.daimon.work-availability.v1` a release reads. */
 export const parseAvailability = (response, route) => {
     if (response.status === 404) {

package/dist/report/types.d.ts

@@ -19,10 +19,7 @@ export interface ContainerRuntimeInstanceReport {
         skill_roots: string[];
     }>;
     config_path: string;
-    /** Per pi/daimon agent (keyed by node id, e.g. "agent:eleanor"): the resolved pi
-     * engine kind (see `PI_ENGINE_KINDS` in `src/runtime/pi/appTemplate.ts`, e.g.
-     * "scripted"), so a scripted-engine run is disclosable on the compile report rather
-     * than an invisible test-only branch. Only pi/daimon runtime instances populate this. */
+    /** Adapter-resolved engine kinds by agent node id. */
     engine_by_node_id?: Record<string, string>;
     home_path: string | null;
     id: string;
@@ -32,8 +29,8 @@ export interface ContainerRuntimeInstanceReport {
     node_ids?: string[];
     published_port?: number | null;
     runtime: string;
-    /** Per pi/daimon agent (keyed by node id, e.g. "agent:eleanor"): the id of its daimon
-     * telemetry persistent mount (see `daimonTelemetryArtifacts.ts`), so
+    /** Per daimon agent (keyed by node id, e.g. "agent:eleanor"): the id of its daimon
+     * telemetry persistent mount, so
      * `artifactsExportPlan.ts` can egress `causal.jsonl` from that agent's durable volume
      * instead of `docker cp`ing it out of the (possibly already-gone) live container. */
     telemetry_mount_ids?: Record<string, string>;

package/dist/runtime/common.d.ts

@@ -39,7 +39,7 @@ export declare const createDiagnostic: (level: DiagnosticReport["level"], messag
 export declare const createDocumentFiles: (baseDirectory: string, documents: ResolvedDocument[]) => EmittedFile[];
 /**
  * Skill roots for the runtimes whose declared skills are read by an external
- * coding-agent CLI engine (`daimon` and `pi`). `.codex/skills` is Codex's own
+ * coding-agent CLI engine (`daimon`). `.codex/skills` is Codex's own
  * workspace discovery root; `.agents/skills` is the generic cross-engine root
  * that grok, agy, and every other file-reading CLI engine use. Both entries
  * are required and the two emitted files are byte-identical on purpose — this

package/dist/runtime/common.js

@@ -64,7 +64,7 @@ export const createDocumentFiles = (baseDirectory, documents) => documents.map((
 }));
 /**
  * Skill roots for the runtimes whose declared skills are read by an external
- * coding-agent CLI engine (`daimon` and `pi`). `.codex/skills` is Codex's own
+ * coding-agent CLI engine (`daimon`). `.codex/skills` is Codex's own
  * workspace discovery root; `.agents/skills` is the generic cross-engine root
  * that grok, agy, and every other file-reading CLI engine use. Both entries
  * are required and the two emitted files are byte-identical on purpose — this

package/dist/runtime/container.d.ts

@@ -1,4 +1,4 @@
-import { type RuntimeContainerPackageOverrides } from "./containerPackageOverrides.js";
+import type { RuntimeContainerPackageOverrides } from "./containerPackageOverrides.js";
 export declare const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
 export interface RuntimeInstallRecipe {
     baseImage?: string;
@@ -33,4 +33,4 @@ export interface RuntimeInstallRecipeOptions {
      */
     packageOverrides?: RuntimeContainerPackageOverrides;
 }
-export declare const createRuntimeInstallRecipe: (runtimeName: string, options?: RuntimeInstallRecipeOptions) => Promise<RuntimeInstallRecipe>;
+export declare const createRuntimeInstallRecipe: (runtimeName: string, _options?: RuntimeInstallRecipeOptions) => Promise<RuntimeInstallRecipe>;

package/dist/runtime/container.js

@@ -1,24 +1,15 @@
-import { DAIMON_PACKAGE_NAME } from './daimon/packageName.js';
 import { createDaimonInstallCommands } from "./daimonInstall.js";
 import { SpawnfileError } from "../shared/index.js";
 import { NOOPOLIS_RUN_ID_ENV, resolveNoopolisRunId } from "./common.js";
-import { createVendorCopyCommand, needsVendorCopyCommand, resolveInstallPackageSpec } from "./containerPackageOverrides.js";
 import { resolveRuntimeInstallSelection } from "./install.js";
 import { DAIMON_LOCAL_RUNTIME_IDENTITY_ENV, loadLocalDaimonRuntimeIdentity } from "./localDaimonAuthority.js";
 import { DAIMON_CONTRACT_MANIFEST_SHA256 } from "./daimon/contractManifest.js";
 import { DAIMON_WAKE_FUSE_DIRECTORY, DAIMON_WAKE_FUSE_DIRECTORY_ENV } from "./daimon/config.js";
 export const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
-const PI_RUNTIME_BASE_IMAGE_ENV = "SPAWNFILE_PI_RUNTIME_BASE_IMAGE";
 const LEGACY_DAIMON_RUNTIME_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_IMAGE";
 const LEGACY_DAIMON_RUNTIME_CAPABILITY_RECEIPT_ENV = "SPAWNFILE_DAIMON_RUNTIME_CAPABILITY_RECEIPT";
 const OPENCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_OPENCLAW_RUNTIME_IMAGE";
 const PICOCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_PICOCLAW_RUNTIME_IMAGE";
-const PI_DAIMON_PACKAGE_VERSION = "0.1.2";
-const MNEME_PACKAGE_NAME = "@noopolis/mneme";
-const MNEME_PACKAGE_VERSION = "0.1.1";
-const PI_AI_PACKAGE_NAME = "@earendil-works/pi-ai";
-const PI_CODING_AGENT_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-const PI_PACKAGE_VERSION = "0.79.10";
 /**
  * Builds the shared container env assembly injected into every generated
  * runtime install recipe. Currently just NOOPOLIS_RUN_ID, sourced from the
@@ -75,12 +66,11 @@ const resolveDaimonRuntimeImageRef = async (selection) => {
         image: pinnedImage
     };
 };
-export const createRuntimeInstallRecipe = async (runtimeName, options = {}) => {
+export const createRuntimeInstallRecipe = async (runtimeName, _options = {}) => {
     const selection = await resolveRuntimeInstallSelection(runtimeName);
     assertArtifactInstallSelection(runtimeName, selection);
     const installRoot = `${RUNTIME_INSTALL_ROOT}/${runtimeName}`;
     const containerEnv = createRuntimeContainerEnv();
-    const packageOverrides = options.packageOverrides;
     switch (runtimeName) {
         case "openclaw": {
             const openClawRuntimeImage = resolveRuntimeImageRef(OPENCLAW_RUNTIME_IMAGE_ENV, selection);
@@ -143,34 +133,6 @@ export const createRuntimeInstallRecipe = async (runtimeName, options = {}) => {
                 runtimeRoot: installRoot
             };
         }
-        case "pi": {
-            if (selection.kind !== "npm") {
-                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
-            }
-            const prebuiltBaseImage = process.env[PI_RUNTIME_BASE_IMAGE_ENV]?.trim() || undefined;
-            const npmPackages = [
-                resolveInstallPackageSpec(DAIMON_PACKAGE_NAME, PI_DAIMON_PACKAGE_VERSION, packageOverrides),
-                resolveInstallPackageSpec(MNEME_PACKAGE_NAME, MNEME_PACKAGE_VERSION, packageOverrides),
-                `${selection.packageName}@${selection.version}`,
-                `${PI_AI_PACKAGE_NAME}@${selection.version}`
-            ];
-            return {
-                ...(prebuiltBaseImage ? { baseImage: prebuiltBaseImage } : {}),
-                commands: prebuiltBaseImage
-                    ? [`mkdir -p ${installRoot}`]
-                    : [
-                        `mkdir -p ${installRoot}`,
-                        `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
-                    ],
-                copyCommands: !prebuiltBaseImage &&
-                    needsVendorCopyCommand([DAIMON_PACKAGE_NAME, MNEME_PACKAGE_NAME], packageOverrides)
-                    ? [createVendorCopyCommand()]
-                    : [],
-                env: containerEnv,
-                runtimeName,
-                runtimeRoot: installRoot
-            };
-        }
         /* c8 ignore next 5 -- compileable runtimes are exhaustively covered above */
         default:
             throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no container install recipe`);

package/dist/runtime/daimon/config.js

@@ -2,10 +2,10 @@ import path from "node:path";
 import { CLI_ENGINE_SKILL_BASE_DIRECTORIES } from "../common.js";
 import { daimonGrokSkillsError } from "./grokSkillsSupport.js";
 import { daimonAgentSkillsFromResolved } from "./grokWorkerSkills.js";
-import { daimonPortableSubscriptionRealms } from "./subscriptionRealms.js";
+import { daimonGatewayedSubscriptionRealms, daimonSubscriptionRealmMountId } from "./subscriptionRealms.js";
 import { parseEveryScheduleMs } from "../scheduleUtils.js";
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_AGY_SUBSCRIPTION_REALM, DAIMON_GROK_SUBSCRIPTION_REALM, DAIMON_GROK_TURN_USAGE_LEDGER } from "./contractManifest.js";
+import { DAIMON_AGY_SUBSCRIPTION_REALM, DAIMON_GROK_TURN_USAGE_LEDGER } from "./contractManifest.js";
 import { DAIMON_INSTANCE_STATE_ROOT, daimonMemoryCapabilityFor, daimonMemorySelectionWarning, daimonMemoryVectorRecallWarning, resolveDaimonAgentMemory } from "./memory.js";
 import { assertDaimonScheduleAuthority } from "./scheduleAuthority.js";
 import { assertDaimonAttentionAuthority, resolveDaimonAttention } from "./attention.js";
@@ -32,7 +32,7 @@ export const DAIMON_RUNTIME_HOMES_DIRECTORY = "runtime-homes";
 const DAIMON_MAX_CONFIG_BYTES = 1_048_576;
 const DAIMON_MAX_INSTRUCTION_BYTES = 16_384;
 const DAIMON_MAX_INSTRUCTION_CODEPOINTS = 16_384;
-import { DAIMON_ENGINES, DAIMON_DEFAULT_ENGINE, getDaimonEngineDescriptor, daimonEngineHasBroker } from "./engines.js";
+import { DAIMON_ENGINES, DAIMON_DEFAULT_ENGINE, DAIMON_SECRET_SERVICE_ENGINE_ID, getDaimonEngineDescriptor, daimonEngineHasBroker } from "./engines.js";
 export { DAIMON_ENGINES } from "./engines.js";
 const normalizeSchedule = (node) => {
     const schedule = node.schedule;
@@ -224,7 +224,7 @@ export const createDaimonContainerTargets = async (inputs) => {
         .map((input) => [input.id, daimonAgentSkillsFromResolved(input.value.skills)]));
     const hasAgy = configAgents.some((agent) => getDaimonEngineDescriptor(agent.engine.kind)?.auth.staging === "secret-service");
     const hasGrok = configAgents.some((agent) => daimonEngineHasBroker(agent.engine.kind));
-    const portableRealms = daimonPortableSubscriptionRealms(configAgents.map((agent) => agent.engine.kind));
+    const portableRealms = daimonGatewayedSubscriptionRealms(configAgents.map((agent) => agent.engine.kind));
     const agyRuntimeHomeMounts = configAgents
         .filter((agent) => getDaimonEngineDescriptor(agent.engine.kind)?.auth.staging === "secret-service")
         .map((agent) => ({
@@ -279,11 +279,10 @@ export const createDaimonContainerTargets = async (inputs) => {
                 }
             ],
             id: DAIMON_ORGANIZATION_TARGET_ID,
-            ...(hasAgy || hasGrok || portableRealms.opaqueMountTargets.length > 0 ? {
+            ...(hasAgy || portableRealms.opaqueMountTargets.length > 0 ? {
                 opaqueMountTargets: [
                     ...portableRealms.opaqueMountTargets,
-                    ...(hasAgy ? [DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath] : []),
-                    ...(hasGrok ? [DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath] : [])
+                    ...(hasAgy ? [DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath] : [])
                 ],
             } : {}),
             persistentMounts: [...portableRealms.persistentMounts, ...portableEngineHomeMounts, ...toolStateMounts, ...recordingMounts, {
@@ -295,12 +294,7 @@ export const createDaimonContainerTargets = async (inputs) => {
                     lifecycle: "exclusive-reattach",
                     mountPath: DAIMON_WAKE_FUSE_DIRECTORY,
                     reason: "Daimon durable wake-fuse admission ledger"
-                }, ...(hasGrok ? [{
-                        id: "daimon-grok-subscription-realm",
-                        lifecycle: "exclusive-reattach",
-                        mountPath: DAIMON_GROK_SUBSCRIPTION_REALM.durableMountPath,
-                        reason: "Daimon host Grok subscription credential realm"
-                    }] : []), {
+                }, {
                     // Non-run-scoped for the same reason as the durable memory mounts (see
                     // durableMemoryVolumeName in src/compiler/memoryArtifacts.ts): a
                     // run-scoped volume means every `spawnfile up` starts a new empty
@@ -321,7 +315,7 @@ export const createDaimonContainerTargets = async (inputs) => {
                     mountPath: DAIMON_GROK_TURN_USAGE_LEDGER.directoryPath,
                     reason: "Daimon per-turn engine usage ledger"
                 }, ...(hasAgy ? [{
-                        id: "daimon-agy-subscription-realm",
+                        id: daimonSubscriptionRealmMountId(DAIMON_SECRET_SERVICE_ENGINE_ID),
                         // The AGY subscription credential is an OS-keyring entry created by an
                         // interactive browser OAuth that has no headless equivalent; it lives
                         // in this volume. Without this lifecycle the volume name folds in the

package/dist/runtime/daimon/contractManifest.js

@@ -253,4 +253,3 @@ export const readVerifiedDaimonContractManifest = async (runtimeRoot) => {
         return fail("digest sidecar does not match its bytes");
     return Object.freeze({ digest: `sha256:${digest}`, manifest: parseDaimonContractManifest(parsed) });
 };
-//# sourceMappingURL=contractManifest.js.map

package/dist/runtime/daimon/contractManifestSchema.js

@@ -25,4 +25,3 @@ export const DAIMON_CONTRACT_MANIFEST_V7_JSON_SCHEMA = {
     ...z.toJSONSchema(daimonContractManifestV7Schema),
     $id: DAIMON_CONTRACT_MANIFEST_V7_VERSION
 };
-//# sourceMappingURL=contractManifestSchema.js.map

package/dist/runtime/daimon/control.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Client for a running Daimon organization's control API (port 19700), reached
+ * the way every other Spawnfile probe reaches a container's loopback: an
+ * ephemeral curl helper from the same image inside the target's network
+ * namespace. The bearer token and any JSON body reach curl as a config on
+ * stdin (`--config -`), never on a command line another host process could read.
+ * Shared by `spawnfile release` (drain/resume) and production-booted training
+ * trials (wakes and receipts).
+ */
+export interface DaimonControlTarget {
+    containerRef: string;
+    dockerArgs: readonly string[];
+    dockerCommand: string;
+    imageRef: string;
+    token: string;
+}
+export interface DaimonControlResponse {
+    body: string;
+    status: number;
+}
+export type DaimonControlMethod = "GET" | "POST";
+export type DaimonControlCall = (target: DaimonControlTarget, method: DaimonControlMethod, route: string, body?: unknown) => Promise<DaimonControlResponse>;
+/** A control call that could not produce an HTTP answer. Its message never carries the token. */
+export declare class DaimonControlError extends Error {
+}
+export declare const DAIMON_CONTROL_CALL_TIMEOUT_MS = 60000;
+export declare const daimonControlHelperArgs: (target: DaimonControlTarget, method: DaimonControlMethod, route: string) => string[];
+/** The stdin config: bearer header, plus a JSON content type and body when one is sent. */
+export declare const daimonControlHelperConfig: (token: string, body?: unknown) => string;
+export declare const parseDaimonControlHelperOutput: (stdout: string) => DaimonControlResponse;
+export declare const daimonHelperControlCall: DaimonControlCall;

package/dist/runtime/daimon/control.js

@@ -0,0 +1,83 @@
+import { spawn } from "node:child_process";
+import { DAIMON_CONTROL_PORT } from "./config.js";
+/** A control call that could not produce an HTTP answer. Its message never carries the token. */
+export class DaimonControlError extends Error {
+}
+export const DAIMON_CONTROL_CALL_TIMEOUT_MS = 60_000;
+const MAX_CONTROL_OUTPUT_BYTES = 1024 * 1024;
+export const daimonControlHelperArgs = (target, method, route) => [
+    ...target.dockerArgs,
+    "run", "--rm", "-i", "--pull", "never",
+    "--network", `container:${target.containerRef}`,
+    "--entrypoint", "curl",
+    target.imageRef,
+    "-sS", "--max-time", "15", "-X", method, "--config", "-",
+    "--output", "-", "--write-out", "\\n%{http_code}",
+    `http://127.0.0.1:${DAIMON_CONTROL_PORT}${route}`
+];
+/** curl config quoting: a double-quoted value with `\` and `"` escaped and no raw newlines. */
+const quoteCurlConfig = (value) => `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"").replace(/\n/gu, "\\n").replace(/\r/gu, "\\r")}"`;
+/** The stdin config: bearer header, plus a JSON content type and body when one is sent. */
+export const daimonControlHelperConfig = (token, body) => [
+    `header = ${quoteCurlConfig(`Authorization: Bearer ${token}`)}`,
+    ...(body === undefined ? [] : [
+        `header = ${quoteCurlConfig("Content-Type: application/json")}`,
+        `data-binary = ${quoteCurlConfig(JSON.stringify(body))}`
+    ])
+].join("\n") + "\n";
+const redact = (text, token) => (token ? text.split(token).join("[redacted]") : text).replace(/\s+/gu, " ").slice(0, 240);
+export const parseDaimonControlHelperOutput = (stdout) => {
+    const match = /\n(\d{3})$/u.exec(stdout);
+    if (!match || match.index === undefined) {
+        throw new DaimonControlError("the runtime control helper returned no HTTP status");
+    }
+    return { body: stdout.slice(0, match.index), status: Number(match[1]) };
+};
+export const daimonHelperControlCall = (target, method, route, body) => new Promise((resolve, reject) => {
+    const child = spawn(target.dockerCommand, daimonControlHelperArgs(target, method, route), {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    const out = [];
+    let bytes = 0;
+    let stderr = "";
+    let settled = false;
+    const finish = (error, value) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        if (error)
+            reject(error);
+        else
+            resolve(value);
+    };
+    const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(new DaimonControlError(`runtime control ${method} ${route} timed out`));
+    }, DAIMON_CONTROL_CALL_TIMEOUT_MS);
+    child.stdout.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > MAX_CONTROL_OUTPUT_BYTES) {
+            child.kill("SIGKILL");
+            finish(new DaimonControlError(`runtime control ${method} ${route} answered more than the output bound`));
+            return;
+        }
+        out.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk.toString("utf8")}`.slice(-2000); });
+    child.once("error", (error) => finish(new DaimonControlError(`cannot start the runtime control helper: ${error.message}`)));
+    child.once("close", (code) => {
+        if (code !== 0) {
+            finish(new DaimonControlError(`runtime control ${method} ${route} failed (exit ${code ?? "signal"}): ${redact(stderr, target.token)}`));
+            return;
+        }
+        try {
+            finish(null, parseDaimonControlHelperOutput(Buffer.concat(out).toString("utf8")));
+        }
+        catch (error) {
+            finish(error);
+        }
+    });
+    child.stdin.on("error", () => undefined);
+    child.stdin.end(daimonControlHelperConfig(target.token, body));
+});

package/dist/runtime/daimon/engineDescriptorSchema.js

@@ -106,4 +106,3 @@ export const parseDaimonEngineDescriptors = (value) => {
     }
     return result.data;
 };
-//# sourceMappingURL=engineDescriptorSchema.js.map

package/dist/runtime/daimon/engineDescriptors.generated.d.ts

@@ -1,4 +1,4 @@
-export declare const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT: "d8aec28df0f0b5705db537136662642416a70d71";
+export declare const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT: "c5337565df0b60151ae731b17878f784c13a9337";
 export declare const DAIMON_V5_ENGINE_DESCRIPTORS: {
     readonly agy: {
         readonly auth: {

package/dist/runtime/daimon/engineDescriptors.generated.js

@@ -1,5 +1,4 @@
 /* v8 ignore file -- generated data module */
 // Generated by scripts/generate-daimon-engine-descriptors.ts from pinned Daimon static descriptors. Do not edit.
-export const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT = "d8aec28df0f0b5705db537136662642416a70d71";
+export const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT = "c5337565df0b60151ae731b17878f784c13a9337";
 export const DAIMON_V5_ENGINE_DESCRIPTORS = { "agy": { "auth": { "busEnvironment": "DBUS_SESSION_BUS_ADDRESS", "format": null, "method": null, "provider": null, "realm": { "directoryMode": 448, "durableMountPath": "/var/lib/spawnfile/daimon/agy-subscription-realm", "fileMode": 384, "maxUnlockBytes": 4096, "unlockMountPath": "/var/lib/spawnfile/daimon/agy-unlock-secret", "unlockSourceSlot": "agy-unlock-secret" }, "staging": "secret-service" }, "authKinds": ["subscription"], "broker": null, "capabilities": { "broker": false, "nativeSandbox": false, "portableCredential": false, "secretService": true }, "credentialMaterial": null, "homeDirectory": "", "homeEnvironment": "ANTIGRAVITY_CLI_HOME", "id": "agy", "modelSelection": { "configurable": false, "declarationRequiresBroker": false, "defaults": { "model": null, "reasoningEffort": null }, "models": null, "reasoningEfforts": [], "requiresPairedDeclaration": false }, "requiredBinaries": ["agy", "dbus-daemon", "gnome-keyring-daemon"], "sandbox": { "configurable": false }, "training": { "inferenceGrants": null, "subject": { "isolation": null, "reason": "no verified per-agent sandbox", "supported": false } } }, "codex": { "auth": { "directoryMode": 448, "fileMode": 384, "fileName": "auth.json", "format": { "accessTokenKeys": ["access_token", "accessToken", "token"], "containerKey": "tokens", "fallbackToRoot": true, "refreshTokenKeys": ["refresh_token", "refreshToken"] }, "maxCredentialBytes": 65536, "method": "codex", "provider": "openai", "realm": { "agentCredentialRelativePath": ".codex/auth.json", "bootstrapMountPath": "/var/lib/spawnfile/daimon/codex-bootstrap-auth", "bootstrapSourceSlot": "codex-auth", "directoryMode": 448, "durableMountPath": "/var/lib/spawnfile/daimon/codex-subscription-realm", "fileMode": 384, "maxCredentialBytes": 65536 }, "staging": "portable-realm" }, "authKinds": ["subscription"], "broker": null, "capabilities": { "broker": false, "nativeSandbox": true, "portableCredential": true, "secretService": false }, "credentialMaterial": { "destinationRelativePath": ".codex/auth.json", "directoryMode": 448, "fileMode": 384, "sourceRelativePath": ".daimon-inbound/codex-auth", "sourceSlot": "codex-auth" }, "homeDirectory": ".codex", "homeEnvironment": "CODEX_HOME", "id": "codex", "modelSelection": { "configurable": true, "declarationRequiresBroker": false, "defaults": { "model": null, "reasoningEffort": null }, "models": { "kind": "non-empty-string" }, "reasoningEfforts": ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra", "persistent"], "requiresPairedDeclaration": false }, "piAuthMethod": "codex", "piProvider": "openai-codex", "piSourceProvider": "openai", "requiredBinaries": ["codex"], "sandbox": { "configurable": true, "policy": { "mode": "workspace-write", "networkAccess": false, "webSearch": "disabled" } }, "training": { "inferenceGrants": null, "subject": { "isolation": "native-sandbox", "supported": true } } }, "grok": { "auth": { "directoryMode": 448, "fileMode": 384, "fileName": "auth.json", "format": { "accessTokenKeys": ["key"], "entryKeyPattern": "^https://auth\\.x\\.ai::", "expiresAtKey": "expires_at", "refreshTokenKeys": ["refresh_token"] }, "maxCredentialBytes": 65536, "method": "grok", "provider": "xai", "realm": { "agentCredentialRelativePath": ".grok/auth.json", "bootstrapMountPath": "/var/lib/spawnfile/daimon/grok-bootstrap-auth", "bootstrapSourceSlot": "grok-auth", "directoryMode": 448, "durableMountPath": "/var/lib/spawnfile/daimon/grok-subscription-realm", "fileMode": 384, "maxCredentialBytes": 65536 }, "staging": "broker-realm" }, "authKinds": ["subscription"], "broker": { "artifacts": { "arm64Sha256": "d0dc1c03197c3e90f09b66ad7c89b4f7b448d06dc84c03b247dce976d6018d6e", "sourceSha256": "15836d7ad69f12ef581a6e5b8635c9db43b2177dac609160c0749d3d1fefbaa8", "x64Sha256": "95aa9c272225e74ff9f45f54dde4bc30aee324e9ba24d8a876db9151c81b454d" }, "backendSocketPath": "/run/daimon-engine-broker/backend.sock", "bounds": { "capabilityBundleBytes": 8196, "capabilityBytes": 4096, "outputBytes": 262144, "promptBytes": 65536 }, "controlProtocolVersion": "noopolis.daimon.engine-broker.v4", "controlSocketPath": "/run/daimon-engine-broker/control.sock", "credentialHomePath": "/var/lib/spawnfile/daimon/grok-subscription-realm", "grokCliArtifacts": { "arm64": { "bytes": 136090504, "sha256": "39ab87666877d64ef3a40aa60fbe0c3b6a6acd7001b78fe60e2c76bb6cfc4a94", "url": "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-aarch64" }, "x64": { "bytes": 163035648, "sha256": "be5905e107d2b8b5f3c142d21ecfe4c8fd32a913d2fd551b788707930c4dc80d", "url": "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-x86_64" } }, "grokCliBuild": "3736acbc8658", "grokCliVersion": "1.0.34", "grokExecutablePath": "/usr/local/bin/grok", "identities": { "brokerUid": 2100, "firstWorkerUid": 2200, "organizationUid": 2000 }, "inferenceGrants": { "bodyMembers": ["messages", "model", "reasoning_effort", "response_format", "stream", "stream_options"], "client": { "configSha256": { "grok-4.5": { "high": "ffbc33728b821e9854fbc7c93601e599225da421ecfd6ebf10d314afcc28d6f2", "low": "a07f7436f1268bb399ec233c65d3b3d8fb99a11a1f175f8da1ca133c9367bc74", "medium": "1f4c0d4dad1f3b09419b5739db6423a09e0049abc091594c64123a75dd53dfb9" }, "grok-4.6": { "high": "5652656effa82f0c4f09cf8226b16e6140332a5a358b571194bb5563312367ac", "low": "79314d039f787e4ebfec7dacf57adc969086b948f564dec008f0ed6367e6062f", "medium": "6f538de0547c0c4e6a3f04ae08595ceadadabb06b75f6b6ee4c428744bb95cd8" }, "grok-build": { "high": "98d16f2b7d12f4eb540d625c853e51d227933e204923e43e8b9b4176f10aca2c", "low": "ca15c6a562a008227d39c51d3a3a83715663089b3784e8b46debb1fb67b3c4a1", "medium": "01783fb6beadcf6f8486fff0836820ad43fab5662b812a907fe9cfdb83e9804d" } }, "envKey": "DAIMON_INFERENCE_GRANT", "modelId": "daimon-inference-grok" }, "failureCodes": ["auth_stale", "grant_limit", "invalid_request", "unavailable"], "ledgerDedupeKey": ["grant", "request"], "ledgerVersion": "noopolis.daimon.inference-usage.v1", "limits": { "maxRequests": 64, "maxTokens": 2000000 }, "maxInFlightRequestsPerGrant": 1, "maxLiveGrants": 8, "messageRoles": ["system", "user", "assistant"], "purposes": ["judge", "optimizer"], "requestKinds": ["request_inference_grant", "release_inference_grant"], "tokenPrefix": "inference_", "ttlMs": 600000 }, "launcherSocketPath": "/run/daimon-engine-broker/launcher.sock", "mcpFacade": { "host": "127.0.0.1", "path": "/mcp", "port": 43124 }, "nativeAbiVersion": 2, "nativeExecutablePath": "/opt/daimon/bin/daimon-engine-broker", "projectionVersion": "noopolis.daimon.grok-broker-projection.v3", "providerProxy": { "host": "127.0.0.1", "port": 43123 }, "registrationPath": "/etc/daimon-engine-broker/registrations.bin", "runRequestBudget": { "countsCredentialRetries": true, "fileName": "run-requests.json", "includesInferenceGrants": true, "maximumField": "maxRunRequests", "storeField": "runRequestStore" }, "serviceConfigPath": "/etc/daimon-engine-broker/service.json", "serviceConfigVersions": ["noopolis.daimon.engine-broker-service.v1", "noopolis.daimon.engine-broker-service.v2", "noopolis.daimon.engine-broker-service.v3"], "slotPreflightVersion": "noopolis.daimon.grok-slot-preflight.v2", "slotRouting": { "controlCaller": "organization", "key": "slot", "repeatedAgentIds": true, "resetRequest": "reset_slot", "resetResponse": "slot_reset", "slotEnvironment": "DAIMON_ENGINE_BROKER_SLOT", "turnStoreDirectory": "slot-{slot}", "workersMayControl": false }, "turnLimits": { "bounds": { "maxRequests": [1, 48], "maxTokens": [1, 10000000], "timeoutMs": [1000, 3600000] }, "keys": ["maxRequests", "maxTokens", "timeoutMs"], "limitReasons": ["tokens", "requests", "timeout", "none"], "maxInFlightRequests": 1, "missingUsageEstimate": { "inputBytesPerToken": 2, "outputTokens": 4096 }, "requestUsageMaxTokens": 500000, "tokenCeilingOvershoot": "at-most-one-request", "v1Defaults": { "maxRequests": 32, "maxTokens": 300000, "timeoutMs": 240000 }, "wakeMayOnlyLower": true }, "turnRecordVersions": ["noopolis.daimon.engine-broker-turn.v1", "noopolis.daimon.engine-broker-turn.v2"], "turnStorePath": "/var/lib/spawnfile/daimon/grok-subscription-realm/turns", "wakeLimitEnvironment": { "maxTokens": "DAIMON_ENGINE_WAKE_TOKEN_CEILING", "timeoutMs": "DAIMON_ENGINE_WAKE_TIMEOUT_MS" }, "worker": { "clockedConfigSha256": { "grok-4.5": { "high": "907d8967960c342b442d6d256b2585f3c85bd846a78578f596f0b605403d6d34", "low": "3c4f3515b21c1bffb3fb770e2ecb4b918b6c43d5e77c1fd47e1e6698d1fedee7", "medium": "9117e12b2f3f6fa045799592969cbaae1c2f3b1ea79330badac8655b9b41dd7a" }, "grok-4.6": { "high": "203744f6f0dfc0bc80cfb896880497edfd9b3de4dcf33060e8ef4d2ef5f220a7", "low": "751f1dcd04983e5e5883df5a8fefa04f201e187e5ef1f344d3bf83f950830432", "medium": "f1406f93a8091eb0c09e07321254a9c783a89b0bbf5548d9613d53a8d087a517" }, "grok-build": { "high": "6efddadc82c38020d3351829e54bb09fa456cd6d76ea1247902794d82a4a3ffa", "low": "a8c63ba910623a0686930c27db0733f4a2588c7fca9dd7da25c3f18027720ab5", "medium": "6afcd2b90c0d19794f8c0d22147a0f011946a92e613f89dae98b0ca729313101" } }, "configSha256": { "grok-4.5": { "high": "c63c3387ce92d94ec3f690abfe98942afcd7c9e17ff84816bbe751f340ab251f", "low": "8247127c3625ff7c5d8d527a53596b89ec6557a821ac46cfd00bd122b90daff6", "medium": "59288cee61297bb8c002097061a48f77b09d310754187a253ee089f7172a9155" }, "grok-4.6": { "high": "65b0212564fb74042b1503d293fb8d3620276033264c0efade2a539ca09218e3", "low": "ab58499ac32678097c146479896f2b8a8e2b0e39aea22dc0a60b6227e370538e", "medium": "df1a5cc84346e7f6bf6090492fbd19faaefb42953e3bb2e8c6cbc0572242403f" }, "grok-build": { "high": "a23724e00d670caee185ba7690d2daa868173e53905cf446f5329666f01ab4e3", "low": "fb343f2809903f26d21681470943235031f946e99085542fd89555eb7782cbb5", "medium": "8a587ef75c90eab70d19b24583e60051d6fba9d90c558839fdbb15588b4cc656" } }, "defaultModel": "grok-4.6", "defaultReasoningEffort": "low", "home": { "directory": { "group": "worker", "mode": 1017, "uid": 0 }, "organizationRuntimeHome": { "group": "worker", "mode": 456, "owner": "organization" }, "privateTmp": { "mode": 448, "owner": "worker", "relativeToWorkerHome": "tmp" }, "readOnlyFiles": { "gid": 0, "mode": 292, "names": ["config.toml", "managed_config.toml", "requirements.toml", "sandbox.toml", "trusted_folders.toml"], "uid": 0 }, "sandboxEvents": { "group": "broker", "mode": 416, "owner": "worker", "relativePath": "sessions/sandbox-events.jsonl" }, "sessionsDirectory": { "group": "worker", "mode": 1017, "relativePath": "sessions", "uid": 0 }, "sharedTmp": { "maxGroupExclusive": 2200, "mode": 1020, "otherMode": 4, "paths": ["/tmp", "/var/tmp"], "uid": 0 }, "spillDirectory": { "fileMode": 416, "group": "worker", "mode": 1512, "owner": "organization", "relativeToRuntimeHome": "tool-output" } }, "maxTurns": 48, "modelId": "daimon-broker-grok", "models": ["grok-4.6", "grok-4.5", "grok-build"], "reasoningEfforts": ["low", "medium", "high"], "systemPromptSha256": "2c31c0085a54a4efbf9c0cf0b8124c56e47f38691b7f0c7fa233a74abaa8ddf8", "taskClock": { "directoryMode": 493, "directoryPath": "/run/daimon-engine-broker/task-clock/slot-0", "fileMode": 420, "ownerUid": 2100, "preloadPath": "/usr/local/lib/daimon/libfaketime.so.1", "rootDirectoryPath": "/run/daimon-engine-broker/task-clock", "slotDirectoryPattern": "/run/daimon-engine-broker/task-clock/slot-{slot}", "slotFilePattern": "/run/daimon-engine-broker/task-clock/slot-{slot}/faketime", "timestampFilePath": "/run/daimon-engine-broker/task-clock/slot-0/faketime", "version": "noopolis.daimon.grok-broker-task-clock.v2", "workerView": "own-directory-visible-sibling-directories-denied" }, "toolIds": ["run_terminal_cmd", "read_file", "grep", "list_dir", "search_tool", "use_tool"], "visibleTools": ["grep", "list_dir", "read_file", "run_terminal_command", "search_tool", "use_tool"] } }, "capabilities": { "broker": true, "nativeSandbox": true, "portableCredential": true, "secretService": false }, "credentialMaterial": { "destinationRelativePath": ".grok/auth.json" }, "homeDirectory": ".grok", "homeEnvironment": "GROK_HOME", "id": "grok", "modelSelection": { "configurable": true, "declarationRequiresBroker": true, "defaults": { "model": "grok-4.6", "reasoningEffort": "low" }, "models": { "kind": "enum", "values": ["grok-4.6", "grok-4.5", "grok-build"] }, "reasoningEfforts": ["low", "medium", "high"], "requiresPairedDeclaration": true }, "requiredBinaries": ["grok", "daimon-engine-broker"], "sandbox": { "baseProfile": "strict", "configurable": false, "denyPaths": { "canonicalAbsolute": true, "forbiddenCharacterPattern": "[\"\\\\\\u0000-\\u001f\\u007f*?[\\]]", "rootAllowed": false, "trailingSlashAllowed": false }, "profile": "daimon-strict", "restrictNetwork": true }, "training": { "inferenceGrants": { "bodyMembers": ["messages", "model", "reasoning_effort", "response_format", "stream", "stream_options"], "client": { "configSha256": { "grok-4.5": { "high": "ffbc33728b821e9854fbc7c93601e599225da421ecfd6ebf10d314afcc28d6f2", "low": "a07f7436f1268bb399ec233c65d3b3d8fb99a11a1f175f8da1ca133c9367bc74", "medium": "1f4c0d4dad1f3b09419b5739db6423a09e0049abc091594c64123a75dd53dfb9" }, "grok-4.6": { "high": "5652656effa82f0c4f09cf8226b16e6140332a5a358b571194bb5563312367ac", "low": "79314d039f787e4ebfec7dacf57adc969086b948f564dec008f0ed6367e6062f", "medium": "6f538de0547c0c4e6a3f04ae08595ceadadabb06b75f6b6ee4c428744bb95cd8" }, "grok-build": { "high": "98d16f2b7d12f4eb540d625c853e51d227933e204923e43e8b9b4176f10aca2c", "low": "ca15c6a562a008227d39c51d3a3a83715663089b3784e8b46debb1fb67b3c4a1", "medium": "01783fb6beadcf6f8486fff0836820ad43fab5662b812a907fe9cfdb83e9804d" } }, "envKey": "DAIMON_INFERENCE_GRANT", "modelId": "daimon-inference-grok" }, "failureCodes": ["auth_stale", "grant_limit", "invalid_request", "unavailable"], "ledgerDedupeKey": ["grant", "request"], "ledgerVersion": "noopolis.daimon.inference-usage.v1", "limits": { "maxRequests": 64, "maxTokens": 2000000 }, "maxInFlightRequestsPerGrant": 1, "maxLiveGrants": 8, "messageRoles": ["system", "user", "assistant"], "purposes": ["judge", "optimizer"], "requestKinds": ["request_inference_grant", "release_inference_grant"], "tokenPrefix": "inference_", "ttlMs": 600000 }, "subject": { "isolation": "broker-worker", "supported": true } } } };
-//# sourceMappingURL=engineDescriptors.generated.js.map

package/dist/runtime/daimon/engines.js

@@ -23,4 +23,3 @@ export const DAIMON_SECRET_SERVICE_ENGINE_ID = byStaging("secret-service", DAIMO
 export const DAIMON_ENGINE_BROKER = byStaging("broker-realm", DAIMON_PINNED_BROKER_DESCRIPTOR.id).broker;
 // Admission additionally consumes training.subject; the declared inventory stays compatible.
 export const daimonTrainingDeclaration = { adapterId: "daimon-native", engines: DAIMON_ENGINES };
-//# sourceMappingURL=engines.js.map

package/dist/runtime/daimon/gateway.d.ts

@@ -0,0 +1,62 @@
+import { type DaimonEngineDescriptor } from "./engines.js";
+/**
+ * In-container placement of Daimon's auth gateway (`daimon-runtime gateway`).
+ *
+ * The gateway is the only process that holds a gatewayed engine's subscription
+ * login. It runs as its own uid on loopback; the organization runtime gets a
+ * URL and a key instead of a realm. These names are Daimon's public contract
+ * (`src/gateway/` and `engines/codex/gatewayProvider.ts` in Daimon).
+ */
+export declare const DAIMON_GATEWAY_URL_ENV = "DAIMON_GATEWAY_URL";
+/** Must keep its `_KEY` suffix: Codex's shell policy keeps `*KEY*` out of model-run commands. */
+export declare const DAIMON_GATEWAY_KEY_ENV = "DAIMON_GATEWAY_KEY";
+export declare const DAIMON_GATEWAY_CONFIG_VERSION = "noopolis.daimon.gateway.v1";
+export declare const DAIMON_GATEWAY_KEY_TABLE_VERSION = "noopolis.daimon.gateway-keys.v1";
+export declare const DAIMON_GATEWAY_HOST = "127.0.0.1";
+export declare const DAIMON_GATEWAY_PORT = 43200;
+export declare const DAIMON_GATEWAY_URL = "http://127.0.0.1:43200";
+/** Root-owned, gateway-group-readable: config and key table. */
+export declare const DAIMON_GATEWAY_ETC = "/etc/daimon-gateway";
+export declare const DAIMON_GATEWAY_CONFIG = "/etc/daimon-gateway/config.json";
+export declare const DAIMON_GATEWAY_KEY_TABLE = "/etc/daimon-gateway/keys.json";
+/** Gateway-private copies of bootstrap leaves, rewritten on every start. */
+export declare const DAIMON_GATEWAY_RUN = "/run/daimon-gateway";
+/**
+ * Bind target directory for gatewayed bootstrap leaves. The host leaf keeps its
+ * host owner (the organization uid), so it is mounted under a root-only 0700
+ * directory the organization uid cannot traverse; root copies it for the gateway.
+ */
+export declare const DAIMON_GATEWAY_BOOTSTRAP_ROOT = "/var/lib/spawnfile/daimon/gateway-bootstrap";
+/** Key-table principal: Daimon reads one gateway key per organization runtime process. */
+export declare const DAIMON_GATEWAY_PRINCIPAL = "daimon-organization";
+export type DaimonGatewayedDescriptor = DaimonEngineDescriptor & {
+    auth: Extract<DaimonEngineDescriptor["auth"], {
+        staging: "portable-realm" | "broker-realm";
+    }>;
+};
+/**
+ * Whether Spawnfile places a gateway for this engine. The descriptors carry
+ * no gateway field, so the seam is the staging role: every realm-staged login
+ * (portable or brokered) is gatewayed; per-agent files and AGY's secret
+ * service never are. Replace with Daimon's own declaration once published.
+ */
+export declare const isDaimonGatewayedEngine: (descriptor: DaimonEngineDescriptor | undefined) => descriptor is DaimonGatewayedDescriptor;
+export declare const daimonGatewayedEngines: (engines: Iterable<string>) => DaimonGatewayedDescriptor[];
+type RealmBootstrap = Readonly<{
+    bootstrapMountPath: string;
+}>;
+/** Where a gatewayed engine's read-only bootstrap leaf is bind-mounted. */
+export declare const daimonGatewayBootstrapMountPath: (realm: RealmBootstrap) => string;
+/** The gateway-owned copy the gateway reads as its bootstrap. */
+export declare const daimonGatewayBootstrapCopyPath: (realm: RealmBootstrap) => string;
+/**
+ * Where the gateway mounts a realm volume. A brokered engine's descriptor
+ * realm path is also its broker's local turn-state home, so its volume moves
+ * to a sibling `gateway-` path; every other realm keeps its descriptor path.
+ */
+export declare const daimonGatewayRealmPath: (descriptor: DaimonGatewayedDescriptor) => string;
+/** Gateway-private refresh home for a brokered engine, whose CLI refreshes its own login. */
+export declare const daimonGatewayRefreshScratchPath: (descriptor: DaimonGatewayedDescriptor) => string | undefined;
+/** `host` is loopback in-container; the training sidecar binds its private network (`0.0.0.0`). */
+export declare const renderDaimonGatewayConfig: (descriptors: readonly DaimonGatewayedDescriptor[], host?: string) => string;
+export {};