spawnfile 0.1.32 → 0.1.34

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: "9eb0560cf44ad02d838eb2dfcf9bd91f353e4a88";
+export declare const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT: "a42a2b23722eadc44874e8caf117d17237e1095f";
 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 = "9eb0560cf44ad02d838eb2dfcf9bd91f353e4a88";
+export const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT = "a42a2b23722eadc44874e8caf117d17237e1095f";
 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 {};

package/dist/runtime/daimon/gateway.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { getDaimonEngineDescriptor } 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 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 const DAIMON_GATEWAY_KEY_ENV = "DAIMON_GATEWAY_KEY";
+export const DAIMON_GATEWAY_CONFIG_VERSION = "noopolis.daimon.gateway.v1";
+export const DAIMON_GATEWAY_KEY_TABLE_VERSION = "noopolis.daimon.gateway-keys.v1";
+export const DAIMON_GATEWAY_HOST = "127.0.0.1";
+export const DAIMON_GATEWAY_PORT = 43_200;
+export const DAIMON_GATEWAY_URL = `http://${DAIMON_GATEWAY_HOST}:${DAIMON_GATEWAY_PORT}`;
+/** Root-owned, gateway-group-readable: config and key table. */
+export const DAIMON_GATEWAY_ETC = "/etc/daimon-gateway";
+export const DAIMON_GATEWAY_CONFIG = `${DAIMON_GATEWAY_ETC}/config.json`;
+export const DAIMON_GATEWAY_KEY_TABLE = `${DAIMON_GATEWAY_ETC}/keys.json`;
+/** Gateway-private copies of bootstrap leaves, rewritten on every start. */
+export 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 const DAIMON_GATEWAY_BOOTSTRAP_ROOT = "/var/lib/spawnfile/daimon/gateway-bootstrap";
+/** Key-table principal: Daimon reads one gateway key per organization runtime process. */
+export const DAIMON_GATEWAY_PRINCIPAL = "daimon-organization";
+/** Staging kinds whose login is one durable realm seeded from a bootstrap leaf: exactly what the gateway owns. */
+const GATEWAYED_STAGINGS = new Set(["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 const isDaimonGatewayedEngine = (descriptor) => descriptor !== undefined && GATEWAYED_STAGINGS.has(descriptor.auth.staging);
+export const daimonGatewayedEngines = (engines) => [...new Set(engines)].sort().flatMap((engine) => {
+    const descriptor = getDaimonEngineDescriptor(engine);
+    return isDaimonGatewayedEngine(descriptor) ? [descriptor] : [];
+});
+/** Where a gatewayed engine's read-only bootstrap leaf is bind-mounted. */
+export const daimonGatewayBootstrapMountPath = (realm) => path.posix.join(DAIMON_GATEWAY_BOOTSTRAP_ROOT, path.posix.basename(realm.bootstrapMountPath));
+/** The gateway-owned copy the gateway reads as its bootstrap. */
+export const daimonGatewayBootstrapCopyPath = (realm) => path.posix.join(DAIMON_GATEWAY_RUN, path.posix.basename(realm.bootstrapMountPath));
+/**
+ * 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 const daimonGatewayRealmPath = (descriptor) => {
+    const durable = descriptor.auth.realm.durableMountPath;
+    return descriptor.broker?.credentialHomePath === durable
+        ? path.posix.join(path.posix.dirname(durable), `gateway-${path.posix.basename(durable)}`)
+        : durable;
+};
+/** Gateway-private refresh home for a brokered engine, whose CLI refreshes its own login. */
+export const daimonGatewayRefreshScratchPath = (descriptor) => descriptor.broker === null ? undefined : path.posix.join(DAIMON_GATEWAY_RUN, `${descriptor.id}-refresh`);
+/** `host` is loopback in-container; the training sidecar binds its private network (`0.0.0.0`). */
+export const renderDaimonGatewayConfig = (descriptors, host = DAIMON_GATEWAY_HOST) => `${JSON.stringify({
+    version: DAIMON_GATEWAY_CONFIG_VERSION,
+    host,
+    port: DAIMON_GATEWAY_PORT,
+    key_table_path: DAIMON_GATEWAY_KEY_TABLE,
+    ...Object.fromEntries(descriptors.map((descriptor) => [descriptor.id, {
+            realm_path: daimonGatewayRealmPath(descriptor),
+            bootstrap_path: daimonGatewayBootstrapCopyPath(descriptor.auth.realm),
+            ...(descriptor.broker === null ? {} : {
+                command: descriptor.broker.grokExecutablePath,
+                scratch_path: daimonGatewayRefreshScratchPath(descriptor)
+            })
+        }]))
+})}\n`;

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

@@ -10,11 +10,6 @@ export declare const resolveDaimonGrokWorkerConfig: (model: DaimonGrokBrokerMode
     bytes: string;
     sha256: string;
 };
-/** Validate Daimon's slot-zero template before substituting only the canonical slot path. */
-export declare const resolveDaimonGrokClockedWorkerConfig: (model: DaimonGrokBrokerModel, reasoningEffort: DaimonGrokBrokerReasoningEffort, slot: number, vendored?: Readonly<Record<string, Readonly<Record<string, string>>>>) => {
-    bytes: string;
-    sha256: string;
-};
 /**
  * Byte mirror of Daimon's `renderGrokWorkerSandboxProfile`
  * (`daimon/src/runtime/grokWorkerSandboxProfile.ts`), pinned to Daimon's own

package/dist/runtime/daimon/grokWorkerContract.js

@@ -2,7 +2,7 @@ import { DAIMON_BROKER_ENGINE_ID, getDaimonEngineDescriptor, DAIMON_ENGINE_BROKE
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_GROK_WORKER_CONFIG_BYTES, DAIMON_GROK_CLOCKED_WORKER_CONFIG_BYTES } from "./grokWorkerConfigBytes.js";
+import { DAIMON_GROK_WORKER_CONFIG_BYTES } from "./grokWorkerConfigBytes.js";
 const workerDescriptor = getDaimonEngineDescriptor(DAIMON_BROKER_ENGINE_ID);
 export const DAIMON_GROK_WORKER_SANDBOX_PROFILE = workerDescriptor.sandbox.profile;
 export const DAIMON_GROK_WORKER_HOME_DIRECTORY = workerDescriptor.homeDirectory;
@@ -23,18 +23,6 @@ export const resolveDaimonGrokWorkerConfig = (model, reasoningEffort, vendored =
     }
     return { bytes, sha256: pin };
 };
-/** Validate Daimon's slot-zero template before substituting only the canonical slot path. */
-export const resolveDaimonGrokClockedWorkerConfig = (model, reasoningEffort, slot, vendored = DAIMON_GROK_CLOCKED_WORKER_CONFIG_BYTES) => {
-    if (!Number.isSafeInteger(slot) || slot < 0)
-        throw new SpawnfileError("compile_error", "Invalid Grok clock slot");
-    const template = vendored[model]?.[reasoningEffort];
-    const pin = DAIMON_ENGINE_BROKER.worker.clockedConfigSha256[model]?.[reasoningEffort];
-    if (!template || sha256(template) !== pin)
-        throw new SpawnfileError("compile_error", "Clocked worker config does not match the contract manifest pin");
-    const clock = DAIMON_ENGINE_BROKER.worker.taskClock;
-    const bytes = template.replaceAll(clock.timestampFilePath, clock.slotFilePattern.replace("{slot}", String(slot)));
-    return { bytes, sha256: sha256(bytes) };
-};
 /**
  * Byte mirror of Daimon's `renderGrokWorkerSandboxProfile`
  * (`daimon/src/runtime/grokWorkerSandboxProfile.ts`), pinned to Daimon's own

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

@@ -2,3 +2,5 @@ export * from './contractManifest.js';
 export { DAIMON_PACKAGE_NAME } from './packageName.js';
 export * from './engines.js';
 export * from './contractManifestSchema.js';
+export { DAIMON_GATEWAY_KEY_ENV, DAIMON_GATEWAY_URL_ENV } from './gateway.js';
+export { isDaimonGatewayRealmMountId } from './subscriptionRealms.js';

package/dist/runtime/daimon/index.js

@@ -2,4 +2,5 @@ export * from './contractManifest.js';
 export { DAIMON_PACKAGE_NAME } from './packageName.js';
 export * from './engines.js';
 export * from './contractManifestSchema.js';
-//# sourceMappingURL=index.js.map
+export { DAIMON_GATEWAY_KEY_ENV, DAIMON_GATEWAY_URL_ENV } from './gateway.js';
+export { isDaimonGatewayRealmMountId } from './subscriptionRealms.js';

package/dist/runtime/daimon/memory.js

@@ -4,7 +4,7 @@ import { SpawnfileError } from "../../shared/index.js";
  * Daimon's organization runtime accepts exactly one `memory` block per agent
  * (`OrganizationRuntimeMemory` = `{ runtimeHomePath, source?, tokenBudget? }`),
  * so lowering picks one declared bank deterministically, the same way the
- * legacy generated-Pi emitter does in `../pi/appAgentConfig.ts`.
+ * legacy generated-Pi emitter did.
  */
 const memoryAccessKey = (access) => `${access.source}:${access.bank.id}`;
 const selectDaimonMemoryAccess = (node) => [...(node.memoryAccess ?? [])].sort((left, right) => memoryAccessKey(left).localeCompare(memoryAccessKey(right)))[0];

package/dist/runtime/daimon/packageName.js

@@ -1,3 +1,2 @@
 /** Package identity used by generated container recipes; never a host dependency. */
 export const DAIMON_PACKAGE_NAME = '@noopolis/daimon';
-//# sourceMappingURL=packageName.js.map

package/dist/runtime/daimon/runAuth.js

@@ -1,3 +1,4 @@
+import { DAIMON_GATEWAY_URL_ENV, daimonGatewayBootstrapMountPath } from "./gateway.js";
 import os from "node:os";
 import path from "node:path";
 import { constants } from "node:fs";
@@ -268,7 +269,9 @@ export const prepareDaimonRuntimeAuth = async (input) => {
         mountArgs.push("-v", `${sourcePath}:${ingressPath}:ro`);
     }
     // Realm auth is staged once per organization, in the historical mount order.
-    for (const staging of ["portable-realm", "broker-realm", "secret-service"]) {
+    // An external auth gateway supplied at boot holds every gatewayed login itself.
+    const externalGateway = Boolean(input.env[DAIMON_GATEWAY_URL_ENV]);
+    for (const staging of externalGateway ? ["secret-service"] : ["portable-realm", "broker-realm", "secret-service"]) {
         for (const engine of new Set(agents.map((agent) => agent.engine.kind))) {
             const descriptor = descriptorForEngine(engine);
             if (descriptor.auth.staging !== staging)
@@ -277,13 +280,13 @@ export const prepareDaimonRuntimeAuth = async (input) => {
             if (descriptor.auth.staging === "portable-realm") {
                 const ownerUid = await assertSafeDaimonSourceFile(source, engine, descriptor.auth.maxCredentialBytes, engine);
                 assertDaimonCredentialContainerOwner(ownerUid, engine, containerCredentialUid);
-                mountArgs.push("-v", `${source}:${descriptor.auth.realm.bootstrapMountPath}:ro`);
+                mountArgs.push("-v", `${source}:${daimonGatewayBootstrapMountPath(descriptor.auth.realm)}:ro`);
             }
             else if (descriptor.auth.staging === "broker-realm") {
                 const realm = descriptor.auth.realm;
-                // The organization uid never reads broker bootstrap material.
+                // Root stages broker bootstrap material for the gateway; the organization uid never reads it.
                 await assertSafeDaimonSourceFile(source, engine, descriptor.auth.maxCredentialBytes, engine);
-                mountArgs.push("-v", `${source}:${realm.bootstrapMountPath}:ro`);
+                mountArgs.push("-v", `${source}:${daimonGatewayBootstrapMountPath(realm)}:ro`);
             }
             else if (descriptor.auth.staging === "secret-service") {
                 const realm = descriptor.auth.realm;

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

@@ -18,5 +18,7 @@
  * rather than something the container can repair.
  */
 export declare const DAIMON_ORGANIZATION_UID = 2000;
+/** The auth gateway: sole holder of every gatewayed subscription realm. */
+export declare const DAIMON_GATEWAY_UID = 2050;
 export declare const DAIMON_BROKER_UID = 2100;
 export declare const DAIMON_FIRST_WORKER_UID = 2200;

package/dist/runtime/daimon/runtimeIdentity.js

@@ -18,5 +18,7 @@
  * rather than something the container can repair.
  */
 export const DAIMON_ORGANIZATION_UID = 2_000;
+/** The auth gateway: sole holder of every gatewayed subscription realm. */
+export const DAIMON_GATEWAY_UID = 2_050;
 export const DAIMON_BROKER_UID = 2_100;
 export const DAIMON_FIRST_WORKER_UID = 2_200;

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

@@ -1,9 +1,15 @@
-export declare const daimonPortableSubscriptionRealms: (engines: readonly string[]) => {
-    opaqueMountTargets: "/var/lib/spawnfile/daimon/codex-bootstrap-auth"[];
+/**
+ * Whether a compiled persistent mount is a gatewayed realm. An organization
+ * booted against an external gateway (`DAIMON_GATEWAY_URL` at boot) mounts
+ * none of these and stages no bootstrap leaf: the gateway alone holds them.
+ */
+export declare const isDaimonGatewayRealmMountId: (id: string) => boolean;
+export declare const daimonGatewayedSubscriptionRealms: (engines: readonly string[]) => {
+    opaqueMountTargets: string[];
     persistentMounts: {
         id: string;
         lifecycle: "exclusive-reattach";
-        mountPath: "/var/lib/spawnfile/daimon/codex-subscription-realm";
+        mountPath: string;
         reason: string;
     }[];
 };

package/dist/runtime/daimon/subscriptionRealms.js

@@ -1,18 +1,27 @@
-import { getDaimonEngineDescriptor } from "./engines.js";
-export const daimonPortableSubscriptionRealms = (engines) => {
-    const realms = [...new Set(engines)].sort().flatMap((engine) => {
-        const descriptor = getDaimonEngineDescriptor(engine);
-        return descriptor?.auth.staging === "portable-realm"
-            ? [{ engine, realm: descriptor.auth.realm }]
-            : [];
-    });
+import { daimonGatewayBootstrapMountPath, daimonGatewayedEngines, daimonGatewayRealmPath } from "./gateway.js";
+import { DAIMON_ENGINES } from "./engines.js";
+/**
+ * Realm resources for every gatewayed engine: one exclusive-reattach realm
+ * volume the auth gateway alone owns, and one opaque bootstrap leaf mounted
+ * under the gateway-private root. The volume id is the realm's identity, so a
+ * moved mount path still reattaches the same login.
+ */
+const realmMountId = (engine) => `daimon-${engine}-subscription-realm`;
+/**
+ * Whether a compiled persistent mount is a gatewayed realm. An organization
+ * booted against an external gateway (`DAIMON_GATEWAY_URL` at boot) mounts
+ * none of these and stages no bootstrap leaf: the gateway alone holds them.
+ */
+export const isDaimonGatewayRealmMountId = (id) => daimonGatewayedEngines(DAIMON_ENGINES).some((descriptor) => realmMountId(descriptor.id) === id);
+export const daimonGatewayedSubscriptionRealms = (engines) => {
+    const descriptors = daimonGatewayedEngines(engines);
     return {
-        opaqueMountTargets: realms.map(({ realm }) => realm.bootstrapMountPath),
-        persistentMounts: realms.map(({ engine, realm }) => ({
-            id: `daimon-${engine}-subscription-realm`,
+        opaqueMountTargets: descriptors.map((descriptor) => daimonGatewayBootstrapMountPath(descriptor.auth.realm)),
+        persistentMounts: descriptors.map((descriptor) => ({
+            id: realmMountId(descriptor.id),
             lifecycle: "exclusive-reattach",
-            mountPath: realm.durableMountPath,
-            reason: `Daimon host ${engine} subscription credential realm`
+            mountPath: daimonGatewayRealmPath(descriptor),
+            reason: `Daimon host ${descriptor.id} subscription credential realm`
         }))
     };
 };

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

@@ -0,0 +1,2 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+export declare const createDaimonTestNode: (overrides?: Partial<ResolvedAgentNode>) => ResolvedAgentNode;

package/dist/runtime/{pi → daimon}/testHelpers.js

@@ -1,5 +1,5 @@
-export const createPiTestNode = (overrides = {}) => ({
-    description: "Pi test agent",
+export const createDaimonTestNode = (overrides = {}) => ({
+    description: "Daimon test agent",
     docs: [
         {
             content: "# Instructions\n",
@@ -23,7 +23,7 @@ export const createPiTestNode = (overrides = {}) => ({
     name: "assistant",
     policyMode: null,
     policyOnDegrade: null,
-    runtime: { name: "pi", options: {} },
+    runtime: { name: "daimon", options: {} },
     secrets: [],
     skills: [
         {

package/dist/runtime/daimon/training/booted/adapter.d.ts

@@ -0,0 +1,46 @@
+import type { SubjectAdapter } from '../../../../training/index.js';
+export declare const BOOTED_ADAPTER_ID = "daimon-booted";
+export declare const BOOTED_EVIDENCE_SCHEMA = "spawnfile.training.daimon-booted.wake.v1";
+/** One ledger row a wake appended (`noopolis.daimon.turn-usage.v1`), as far as Training reads it. */
+export interface BootedUsageRow {
+    input: number;
+    cache_read: number;
+    output: number;
+    notional_usd: number;
+    complete: boolean;
+}
+export interface BootedWake {
+    state: 'completed' | 'failed' | 'stopped' | 'timeout';
+    acceptanceId: string;
+    executionId: string | null;
+    code: string | null;
+    text: string;
+    usage: readonly BootedUsageRow[];
+    transcript: string | null;
+}
+export interface BootedTrialHandle {
+    wake(text: string, options: {
+        deliveryId: string;
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }): Promise<BootedWake>;
+    teardown(): Promise<void>;
+}
+/** Boots one trial organization of the subject with the candidate's instructions. */
+export interface BootedTrialLauncher {
+    boot(input: {
+        trialId: string;
+        instructions: string;
+        signal?: AbortSignal;
+    }): Promise<BootedTrialHandle>;
+}
+export interface BootedAdapterOptions {
+    launcher: BootedTrialLauncher;
+    timeoutMs: number;
+}
+/**
+ * A training trial as a production-booted organization: the container is the
+ * isolation, the wake is the turn, and the evidence is what the runtime itself
+ * recorded (receipt, usage ledger, engine transcript).
+ */
+export declare function createDaimonBootedAdapter(options: BootedAdapterOptions): SubjectAdapter;