spawnfile 0.1.13 → 0.1.17

package/dist/runtime/daimon/config.js

@@ -0,0 +1,272 @@
+import path from "node:path";
+import { parseEveryScheduleMs } from "../scheduleUtils.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { DAIMON_AGY_SUBSCRIPTION_REALM, DAIMON_ENGINE_CREDENTIALS, DAIMON_GROK_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";
+import { resolveDaimonGrokModel } from "./grokModel.js";
+export const DAIMON_CODEX_WORKSPACE_NO_NETWORK_POLICY = { mode: "workspace-write", networkAccess: false, webSearch: "disabled" };
+// Re-exported so every existing importer of these names keeps working; the
+// definitions themselves now live in `./memory.js`.
+export { DAIMON_INSTANCE_STATE_ROOT, daimonMemoryCapabilityFor, daimonMemorySelectionWarning, daimonMemoryVectorRecallWarning, resolveDaimonAgentMemory };
+export const DAIMON_CONFIG_FILE = "daimon-organization-runtime.json";
+export const DAIMON_CONTROL_PORT = 19700;
+export const DAIMON_MAX_AGENTS = 32;
+export const DAIMON_ORGANIZATION_TARGET_ID = "daimon-organization";
+export const DAIMON_RUNTIME_ACCEPTANCE_STORE_DIRECTORY = "state/wake-acceptance";
+export const DAIMON_RUNTIME_ACCEPTANCE_STORE_ENV = "DAIMON_RUNTIME_ACCEPTANCE_STORE";
+export const DAIMON_RUNTIME_ACCEPTANCE_STORE_MOUNT_ID = "daimon-organization-acceptance-store";
+export const DAIMON_RUNTIME_READINESS_RECEIPT_ENV = "DAIMON_RUNTIME_READINESS_RECEIPT";
+export const DAIMON_WAKE_FUSE_DIRECTORY = "/var/lib/spawnfile/daimon/wake-fuse";
+export const DAIMON_WAKE_FUSE_DIRECTORY_ENV = "DAIMON_WAKE_FUSE_DIRECTORY";
+export const DAIMON_WAKE_FUSE_MOUNT_ID = "daimon-wake-fuse";
+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;
+export const DAIMON_ENGINES = ["agy", "codex", "grok"];
+const normalizeSchedule = (node) => {
+    const schedule = node.schedule;
+    if (!schedule || schedule.kind === "disabled")
+        return schedule ? { kind: "disabled" } : undefined;
+    if (schedule.kind === "every") {
+        const interval_ms = parseEveryScheduleMs(schedule.every);
+        if (interval_ms === null)
+            throw new SpawnfileError("validation_error", `invalid every schedule for ${node.name}`);
+        return {
+            kind: "every", interval_ms, prompt: schedule.prompt ?? "Scheduled work",
+            ...(schedule.jitter_seconds === undefined ? {} : { jitter_seconds: schedule.jitter_seconds })
+        };
+    }
+    return {
+        cron: schedule.cron.trim().replace(/\s+/gu, " "),
+        kind: "cron",
+        prompt: schedule.prompt ?? "Scheduled work",
+        timezone: schedule.timezone ?? "UTC",
+        ...(schedule.jitter_seconds === undefined ? {} : { jitter_seconds: schedule.jitter_seconds })
+    };
+};
+const formatInstructions = (node) => node.docs.map((document) => `# ${document.role}\n\n${document.content}`).join("\n\n").trim() ||
+    `You are ${node.name}. Follow the workspace instructions.`;
+const assertPublicInstructionBounds = (agentId, instructions) => {
+    if (Buffer.byteLength(instructions, "utf8") > DAIMON_MAX_INSTRUCTION_BYTES ||
+        [...instructions].length > DAIMON_MAX_INSTRUCTION_CODEPOINTS) {
+        throw new SpawnfileError("validation_error", `Daimon organization runtime v1 instructions for ${agentId} exceed Daimon's public config limit`);
+    }
+};
+export const resolveDaimonEngine = (node) => {
+    const engine = node.runtime.options.engine ?? "codex";
+    if (typeof engine === "string" && DAIMON_ENGINES.includes(engine)) {
+        return engine;
+    }
+    throw new SpawnfileError("validation_error", `Daimon runtime option engine must be one of ${DAIMON_ENGINES.join(", ")}`);
+};
+const resolveDaimonEngineConfig = (node) => {
+    const kind = resolveDaimonEngine(node);
+    if (kind === "grok") {
+        const declared = resolveDaimonGrokModel(node);
+        return { kind, model: declared.model, reasoningEffort: declared.reasoningEffort };
+    }
+    const model = kind === "codex" ? node.execution?.model?.primary?.name : undefined;
+    const codexSandbox = kind === "codex" && node.runtime.options.codex_policy === "workspace-no-network"
+        ? DAIMON_CODEX_WORKSPACE_NO_NETWORK_POLICY
+        : undefined;
+    return {
+        kind,
+        ...(model === undefined ? {} : { model }),
+        ...(codexSandbox === undefined ? {} : { codexSandbox })
+    };
+};
+const moveWorkspaceFile = (file, slug) => file.path.startsWith("workspace/")
+    ? { ...file, path: path.posix.join("workspace", "agents", slug, file.path.slice("workspace/".length)) }
+    : file;
+const renderStartScript = (agents) => {
+    const acceptanceStorePath = `<instance-root>/${DAIMON_RUNTIME_ACCEPTANCE_STORE_DIRECTORY}`;
+    const readinessReceiptPath = `${acceptanceStorePath}/runtime-readiness.json`;
+    const setup = agents.flatMap((agent) => {
+        const credential = agent.engine.kind === "codex"
+            ? DAIMON_ENGINE_CREDENTIALS.codex
+            : undefined;
+        const inbound = path.posix.join(agent.runtimeHomePath, ".daimon-inbound");
+        return [
+            // The workspace mode is owned by the uid entrypoint, which grants a grok worker
+            // group access. Forcing 0700 here would lock that worker out of its own workspace,
+            // so create it only when absent and never restate the mode of an existing directory.
+            `[ -d ${JSON.stringify(agent.workspacePath)} ] || install -d -m 700 ${JSON.stringify(agent.workspacePath)}`,
+            // A Grok agent's runtime home is traversable by its worker's group (the
+            // broker provisioning grants `0710` so the worker can read its setgid
+            // `tool-output/` spills); restating 0700 here would revoke that.
+            agent.engine.kind === "grok"
+                ? `[ -d ${JSON.stringify(agent.runtimeHomePath)} ] || install -d -m 700 ${JSON.stringify(agent.runtimeHomePath)}`
+                : `install -d -m 700 ${[
+                    agent.runtimeHomePath,
+                    ...(credential === undefined ? [] : [inbound])
+                ].map((entry) => JSON.stringify(entry)).join(" ")}`,
+            ...(credential === undefined ? [] : [
+                `if [ -e ${JSON.stringify(path.posix.join(agent.runtimeHomePath, credential.sourceRelativePath))} ]; then test "$(stat -c %a ${JSON.stringify(path.posix.join(agent.runtimeHomePath, credential.sourceRelativePath))})" = 600; fi`
+            ])
+        ];
+    });
+    return [
+        "#!/usr/bin/env bash",
+        "set -euo pipefail",
+        `install -d -m 700 ${JSON.stringify(acceptanceStorePath)}`,
+        `export ${DAIMON_RUNTIME_ACCEPTANCE_STORE_ENV}=${JSON.stringify(acceptanceStorePath)}`,
+        `rm -f ${JSON.stringify(readinessReceiptPath)}`,
+        `export ${DAIMON_RUNTIME_READINESS_RECEIPT_ENV}=${JSON.stringify(readinessReceiptPath)}`,
+        ...setup,
+        'if [ "$#" -gt 0 ]; then exec daimon-runtime "$@"; fi',
+        "exec daimon-runtime run --config <config-path>"
+    ].join("\n") + "\n";
+};
+export const createDaimonContainerTargets = async (inputs) => {
+    const agents = inputs.filter((input) => input.kind === "agent" && input.value.kind === "agent");
+    if (agents.length === 0)
+        return [];
+    if (agents.length > DAIMON_MAX_AGENTS) {
+        throw new SpawnfileError("validation_error", `Daimon organization runtime v1 supports at most 32 agents; found ${agents.length}. Split the organization across explicit runtime boundaries.`);
+    }
+    const hasSchedules = agents.some((input) => input.value.schedule !== undefined);
+    const attentionById = new Map(agents.map((input) => [input.id, resolveDaimonAttention(input.value.runtime.options.attention)]));
+    const hasAttention = [...attentionById.values()].some((attention) => attention !== undefined);
+    if (hasAttention)
+        await assertDaimonAttentionAuthority();
+    if (hasSchedules)
+        await assertDaimonScheduleAuthority();
+    const configAgents = agents
+        .map((input) => {
+        const memory = resolveDaimonAgentMemory(input.value);
+        return {
+            engine: resolveDaimonEngineConfig(input.value),
+            id: input.id,
+            instructions: formatInstructions(input.value),
+            name: input.value.name,
+            ...(input.value.mcpServers.length === 0 ? {} : { mcp: input.value.mcpServers.map((server) => ({
+                    name: server.name, transport: server.transport, args: server.args ?? [], env: server.env ?? {}, tools: server.tools,
+                    ...(server.command ? { command: server.command } : {}), ...(server.url ? { url: server.url } : {}),
+                    ...(server.auth?.mode === "bearer" ? { authSecretEnv: server.auth.secret } : {})
+                })) }),
+            ...(memory ? { memory } : {}),
+            ...(attentionById.get(input.id) === undefined ? {} : { attention: attentionById.get(input.id) }),
+            ...(input.value.surfaces?.moltnet?.length ? { moltnet: {
+                    cliPath: "/usr/local/bin/moltnet",
+                    configPath: `<workspace-path>/agents/${input.slug}/.moltnet/config.json`,
+                    networks: input.value.surfaces.moltnet.map((attachment) => ({ id: attachment.network, rooms: Object.keys(attachment.rooms ?? {}).sort(), dms: attachment.dms?.enabled === true }))
+                } } : {}),
+            runtimeHomePath: `<instance-root>/${DAIMON_RUNTIME_HOMES_DIRECTORY}/${input.slug}`,
+            workspacePath: `<workspace-path>/agents/${input.slug}`,
+            ...(hasSchedules || hasAttention ? { schedule: normalizeSchedule(input.value) ?? { kind: "disabled" } } : {})
+        };
+    })
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const engineByNodeId = Object.fromEntries(configAgents.map((agent) => [agent.id, agent.engine.kind]));
+    const grokModelByNodeId = Object.fromEntries(configAgents
+        .filter((agent) => agent.engine.kind === "grok" && agent.engine.model !== undefined && agent.engine.reasoningEffort !== undefined)
+        .map((agent) => [agent.id, { model: agent.engine.model, reasoningEffort: agent.engine.reasoningEffort }]));
+    const hasAgy = configAgents.some((agent) => agent.engine.kind === "agy");
+    const hasGrok = configAgents.some((agent) => agent.engine.kind === "grok");
+    const agyRuntimeHomeMounts = configAgents
+        .filter((agent) => agent.engine.kind === "agy")
+        .map((agent) => ({
+        id: `daimon-agy-runtime-home-${path.posix.basename(agent.runtimeHomePath)}`,
+        mountPath: agent.runtimeHomePath,
+        reason: `Daimon AGY subscription runtime home for ${agent.id}`
+    }));
+    const portableEngineHomeMounts = configAgents
+        .filter((agent) => agent.engine.kind !== "agy")
+        .map((agent) => {
+        const destinationRelativePath = agent.engine.kind === "grok"
+            ? DAIMON_GROK_SUBSCRIPTION_REALM.agentCredentialRelativePath
+            : DAIMON_ENGINE_CREDENTIALS.codex.destinationRelativePath;
+        return {
+            id: `daimon-engine-home-${agent.engine.kind}-${path.posix.basename(agent.runtimeHomePath)}`,
+            mountPath: path.posix.join(agent.runtimeHomePath, path.posix.dirname(destinationRelativePath)),
+            reason: `Daimon ${agent.engine.kind} subscription credential home for ${agent.id}`
+        };
+    });
+    const toolStateMounts = configAgents.map((agent) => ({ id: `daimon-tool-state-${path.posix.basename(agent.runtimeHomePath)}`, mountPath: path.posix.join(agent.runtimeHomePath, "tool-state"), reason: `Daimon durable cognition tool receipts for ${agent.id}` }));
+    for (const agent of configAgents)
+        assertPublicInstructionBounds(agent.id, agent.instructions);
+    const config = {
+        agents: configAgents,
+        host: {
+            bindHost: "127.0.0.1",
+            controlTokenEnv: "SPAWNFILE_DAIMON_CONTROL_TOKEN",
+            port: DAIMON_CONTROL_PORT
+        },
+        version: hasSchedules || hasAttention
+            ? "noopolis.daimon.organization-runtime.v2"
+            : "noopolis.daimon.organization-runtime.v1"
+    };
+    const serializedConfig = `${JSON.stringify(config, null, 2)}\n`;
+    if (Buffer.byteLength(serializedConfig, "utf8") > DAIMON_MAX_CONFIG_BYTES) {
+        throw new SpawnfileError("validation_error", "Daimon organization runtime v1 config exceeds Daimon's public config limit");
+    }
+    return [{
+            engineByNodeId,
+            ...(hasGrok ? { grokModelByNodeId } : {}),
+            files: [
+                ...agents.flatMap((input) => input.emittedFiles.map((file) => moveWorkspaceFile(file, input.slug))),
+                { content: serializedConfig, path: DAIMON_CONFIG_FILE },
+                {
+                    content: renderStartScript(configAgents),
+                    mode: 0o755,
+                    path: "runtime/daimon-start.sh"
+                }
+            ],
+            id: DAIMON_ORGANIZATION_TARGET_ID,
+            ...(hasAgy || hasGrok ? {
+                opaqueMountTargets: [
+                    ...(hasAgy ? [DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath] : []),
+                    ...(hasGrok ? [DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath] : [])
+                ],
+            } : {}),
+            persistentMounts: [...portableEngineHomeMounts, ...toolStateMounts, {
+                    id: DAIMON_RUNTIME_ACCEPTANCE_STORE_MOUNT_ID,
+                    mountPath: `<instance-root>/${DAIMON_RUNTIME_ACCEPTANCE_STORE_DIRECTORY}`,
+                    reason: "Daimon organization durable wake acceptance store"
+                }, {
+                    id: DAIMON_WAKE_FUSE_MOUNT_ID,
+                    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
+                    // ledger and cross-deployment usage accounting is impossible. The
+                    // exclusive reservation this lifecycle carries is a requirement, not a
+                    // cost.
+                    // The mount id is deliberately unchanged now that AGY and Codex write
+                    // here too, not just the broker: it is the volume's identity, and
+                    // renaming it would orphan every existing deployment's accumulated
+                    // ledger. Unconditional (not gated on hasGrok/hasAgy) because Daimon's
+                    // wake fuse now refuses to arm at all if this directory or the ledger
+                    // file inside it is missing or unreadable (`wakeFuse.ts`,
+                    // `ensureUsageLedgerReadable`), and Codex also writes here
+                    // (`engineDispatcher.ts`'s `onTurnUsage`) even in a codex-only
+                    // organization with no Grok or AGY agent at all.
+                    id: "daimon-grok-usage-ledger",
+                    lifecycle: "exclusive-reattach",
+                    mountPath: DAIMON_GROK_TURN_USAGE_LEDGER.directoryPath,
+                    reason: "Daimon per-turn engine usage ledger"
+                }, ...(hasAgy ? [{
+                        id: "daimon-agy-subscription-realm",
+                        // 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
+                        // run id, so every `spawnfile up` would hand the container an empty
+                        // keyring and the operator would have to re-enrol by hand.
+                        lifecycle: "exclusive-reattach",
+                        mountPath: DAIMON_AGY_SUBSCRIPTION_REALM.durableMountPath,
+                        reason: "Daimon host AGY subscription realm"
+                    }, ...agyRuntimeHomeMounts] : [])],
+            sourceIds: agents.map((agent) => agent.id).sort()
+        }];
+};

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

@@ -0,0 +1,295 @@
+export declare const DAIMON_CONTRACT_MANIFEST_VERSION: "noopolis.daimon.runtime-contract-manifest.v3";
+export declare const DAIMON_CONTRACT_MANIFEST_SHA256: "sha256:c672ed47e4a01a75f1482ea6e4b6ecb28205aab344741a10cad8783f5501b6c4";
+export declare const DAIMON_CONTRACT_MANIFEST_FILE = "contract-manifest.json";
+export declare const DAIMON_CONTRACT_MANIFEST_DIGEST_FILE = "contract-manifest.sha256";
+export declare const DAIMON_RUNTIME_HOME_ROOT = "/var/lib/spawnfile/instances/daimon";
+export declare const DAIMON_ENGINE_KINDS: readonly ["agy", "codex", "grok"];
+export declare const DAIMON_ORGANIZATION_RUNTIME_CONFIG_VERSIONS: readonly ["noopolis.daimon.organization-runtime.v1", "noopolis.daimon.organization-runtime.v2"];
+export declare const DAIMON_ENGINE_CREDENTIALS: {
+    readonly codex: {
+        readonly destinationRelativePath: ".codex/auth.json";
+        readonly directoryMode: 448;
+        readonly fileMode: 384;
+        readonly sourceRelativePath: ".daimon-inbound/codex-auth";
+        readonly sourceSlot: "codex-auth";
+    };
+};
+export declare const DAIMON_GROK_SUBSCRIPTION_REALM: {
+    readonly agentCredentialRelativePath: ".grok/auth.json";
+    readonly bootstrapMountPath: "/var/lib/spawnfile/daimon/grok-bootstrap-auth";
+    readonly bootstrapSourceSlot: "grok-auth";
+    readonly directoryMode: 448;
+    readonly durableMountPath: "/var/lib/spawnfile/daimon/grok-subscription-realm";
+    readonly fileMode: 384;
+    readonly maxCredentialBytes: number;
+};
+export declare const DAIMON_GROK_BROKER_MODELS: readonly ["grok-4.6", "grok-4.5", "grok-build"];
+export declare const DAIMON_GROK_BROKER_REASONING_EFFORTS: readonly ["low", "medium", "high"];
+export type DaimonGrokBrokerModel = typeof DAIMON_GROK_BROKER_MODELS[number];
+export type DaimonGrokBrokerReasoningEffort = typeof DAIMON_GROK_BROKER_REASONING_EFFORTS[number];
+/**
+ * Byte mirror of Daimon's `GROK_ENGINE_BROKER` (daimon
+ * `src/contracts/runtimeContractManifest.ts`), attested key-for-key against the
+ * vendored `contract-manifest.json` by `parseDaimonContractManifest`.
+ */
+export declare const DAIMON_GROK_ENGINE_BROKER: {
+    readonly nativeAbiVersion: 2;
+    readonly nativeExecutablePath: "/opt/daimon/bin/daimon-engine-broker";
+    readonly grokExecutablePath: "/usr/local/bin/grok";
+    readonly registrationPath: "/etc/daimon-engine-broker/registrations.bin";
+    readonly credentialHomePath: "/var/lib/spawnfile/daimon/grok-subscription-realm";
+    readonly turnStorePath: "/var/lib/spawnfile/daimon/grok-subscription-realm/turns";
+    readonly controlSocketPath: "/run/daimon-engine-broker/control.sock";
+    readonly backendSocketPath: "/run/daimon-engine-broker/backend.sock";
+    readonly launcherSocketPath: "/run/daimon-engine-broker/launcher.sock";
+    readonly serviceConfigPath: "/etc/daimon-engine-broker/service.json";
+    readonly providerProxy: {
+        readonly host: "127.0.0.1";
+        readonly port: 43123;
+    };
+    readonly mcpFacade: {
+        readonly host: "127.0.0.1";
+        readonly port: 43124;
+        readonly path: "/mcp";
+    };
+    readonly identities: {
+        readonly organizationUid: 2000;
+        readonly brokerUid: 2100;
+        readonly firstWorkerUid: 2200;
+    };
+    readonly grokCliVersion: "1.0.34";
+    readonly grokCliBuild: "3736acbc8658";
+    readonly grokCliArtifacts: {
+        readonly arm64: {
+            readonly url: "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-aarch64";
+            readonly sha256: "39ab87666877d64ef3a40aa60fbe0c3b6a6acd7001b78fe60e2c76bb6cfc4a94";
+            readonly bytes: 136090504;
+        };
+        readonly x64: {
+            readonly url: "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-x86_64";
+            readonly sha256: "be5905e107d2b8b5f3c142d21ecfe4c8fd32a913d2fd551b788707930c4dc80d";
+            readonly bytes: 163035648;
+        };
+    };
+    readonly worker: {
+        readonly modelId: "daimon-broker-grok";
+        readonly models: readonly ["grok-4.6", "grok-4.5", "grok-build"];
+        readonly reasoningEfforts: readonly ["low", "medium", "high"];
+        readonly defaultModel: "grok-4.6";
+        readonly defaultReasoningEffort: "low";
+        readonly toolIds: readonly ["run_terminal_cmd", "read_file", "grep", "list_dir", "search_tool", "use_tool"];
+        readonly visibleTools: readonly ["grep", "list_dir", "read_file", "run_terminal_command", "search_tool", "use_tool"];
+        readonly maxTurns: 48;
+        readonly systemPromptSha256: "2c31c0085a54a4efbf9c0cf0b8124c56e47f38691b7f0c7fa233a74abaa8ddf8";
+        readonly configSha256: {
+            readonly "grok-4.6": {
+                readonly low: "ab58499ac32678097c146479896f2b8a8e2b0e39aea22dc0a60b6227e370538e";
+                readonly medium: "df1a5cc84346e7f6bf6090492fbd19faaefb42953e3bb2e8c6cbc0572242403f";
+                readonly high: "65b0212564fb74042b1503d293fb8d3620276033264c0efade2a539ca09218e3";
+            };
+            readonly "grok-4.5": {
+                readonly low: "8247127c3625ff7c5d8d527a53596b89ec6557a821ac46cfd00bd122b90daff6";
+                readonly medium: "59288cee61297bb8c002097061a48f77b09d310754187a253ee089f7172a9155";
+                readonly high: "c63c3387ce92d94ec3f690abfe98942afcd7c9e17ff84816bbe751f340ab251f";
+            };
+            readonly "grok-build": {
+                readonly low: "fb343f2809903f26d21681470943235031f946e99085542fd89555eb7782cbb5";
+                readonly medium: "8a587ef75c90eab70d19b24583e60051d6fba9d90c558839fdbb15588b4cc656";
+                readonly high: "a23724e00d670caee185ba7690d2daa868173e53905cf446f5329666f01ab4e3";
+            };
+        };
+        readonly home: {
+            readonly directory: {
+                readonly uid: 0;
+                readonly group: "worker";
+                readonly mode: 1017;
+            };
+            readonly sessionsDirectory: {
+                readonly relativePath: "sessions";
+                readonly uid: 0;
+                readonly group: "worker";
+                readonly mode: 1017;
+            };
+            readonly readOnlyFiles: {
+                readonly names: readonly ["config.toml", "managed_config.toml", "requirements.toml", "sandbox.toml", "trusted_folders.toml"];
+                readonly uid: 0;
+                readonly gid: 0;
+                readonly mode: 292;
+            };
+            readonly sandboxEvents: {
+                readonly relativePath: "sessions/sandbox-events.jsonl";
+                readonly owner: "worker";
+                readonly group: "broker";
+                readonly mode: 416;
+            };
+            readonly privateTmp: {
+                readonly relativeToWorkerHome: "tmp";
+                readonly owner: "worker";
+                readonly mode: 448;
+            };
+            readonly sharedTmp: {
+                readonly paths: readonly ["/tmp", "/var/tmp"];
+                readonly uid: 0;
+                readonly maxGroupExclusive: 2200;
+                readonly otherMode: 4;
+                readonly mode: 1020;
+            };
+            readonly organizationRuntimeHome: {
+                readonly owner: "organization";
+                readonly group: "worker";
+                readonly mode: 456;
+            };
+            readonly spillDirectory: {
+                readonly relativeToRuntimeHome: "tool-output";
+                readonly owner: "organization";
+                readonly group: "worker";
+                readonly mode: 1512;
+                readonly fileMode: 416;
+            };
+        };
+    };
+    readonly bounds: {
+        readonly promptBytes: 65536;
+        readonly capabilityBytes: 4096;
+        readonly capabilityBundleBytes: 8196;
+        readonly outputBytes: 262144;
+    };
+    readonly controlProtocolVersion: "noopolis.daimon.engine-broker.v2";
+    readonly turnRecordVersions: readonly ["noopolis.daimon.engine-broker-turn.v1", "noopolis.daimon.engine-broker-turn.v2"];
+    readonly serviceConfigVersions: readonly ["noopolis.daimon.engine-broker-service.v1", "noopolis.daimon.engine-broker-service.v2"];
+    readonly turnLimits: {
+        readonly keys: readonly ["maxRequests", "maxTokens", "timeoutMs"];
+        readonly v1Defaults: {
+            readonly maxRequests: 32;
+            readonly maxTokens: 300000;
+            readonly timeoutMs: 240000;
+        };
+        readonly bounds: {
+            readonly maxRequests: readonly [1, 48];
+            readonly maxTokens: readonly [1, 10000000];
+            readonly timeoutMs: readonly [1000, 3600000];
+        };
+        readonly limitReasons: readonly ["tokens", "requests", "timeout", "none"];
+        readonly wakeMayOnlyLower: true;
+        readonly tokenCeilingOvershoot: "at-most-one-request";
+        readonly maxInFlightRequests: 1;
+        readonly requestUsageMaxTokens: 500000;
+        readonly missingUsageEstimate: {
+            readonly inputBytesPerToken: 2;
+            readonly outputTokens: 4096;
+        };
+    };
+    readonly wakeLimitEnvironment: {
+        readonly timeoutMs: "DAIMON_ENGINE_WAKE_TIMEOUT_MS";
+        readonly maxTokens: "DAIMON_ENGINE_WAKE_TOKEN_CEILING";
+    };
+    readonly projectionVersion: "noopolis.daimon.grok-broker-projection.v1";
+    readonly slotPreflightVersion: "noopolis.daimon.grok-slot-preflight.v2";
+    readonly inferenceGrants: {
+        readonly requestKinds: readonly ["request_inference_grant", "release_inference_grant"];
+        readonly purposes: readonly ["judge", "optimizer"];
+        readonly tokenPrefix: "inference_";
+        readonly ttlMs: 600000;
+        readonly limits: {
+            readonly maxRequests: 64;
+            readonly maxTokens: 2000000;
+        };
+        readonly maxLiveGrants: 8;
+        readonly maxInFlightRequestsPerGrant: 1;
+        readonly bodyMembers: readonly ["messages", "model", "reasoning_effort", "response_format", "stream", "stream_options"];
+        readonly messageRoles: readonly ["system", "user", "assistant"];
+        readonly failureCodes: readonly ["auth_stale", "grant_limit", "invalid_request", "unavailable"];
+        readonly ledgerVersion: "noopolis.daimon.inference-usage.v1";
+        readonly ledgerDedupeKey: readonly ["grant", "request"];
+        readonly client: {
+            readonly modelId: "daimon-inference-grok";
+            readonly envKey: "DAIMON_INFERENCE_GRANT";
+            readonly configSha256: {
+                readonly "grok-4.6": {
+                    readonly low: "79314d039f787e4ebfec7dacf57adc969086b948f564dec008f0ed6367e6062f";
+                    readonly medium: "6f538de0547c0c4e6a3f04ae08595ceadadabb06b75f6b6ee4c428744bb95cd8";
+                    readonly high: "5652656effa82f0c4f09cf8226b16e6140332a5a358b571194bb5563312367ac";
+                };
+                readonly "grok-4.5": {
+                    readonly low: "a07f7436f1268bb399ec233c65d3b3d8fb99a11a1f175f8da1ca133c9367bc74";
+                    readonly medium: "1f4c0d4dad1f3b09419b5739db6423a09e0049abc091594c64123a75dd53dfb9";
+                    readonly high: "ffbc33728b821e9854fbc7c93601e599225da421ecfd6ebf10d314afcc28d6f2";
+                };
+                readonly "grok-build": {
+                    readonly low: "ca15c6a562a008227d39c51d3a3a83715663089b3784e8b46debb1fb67b3c4a1";
+                    readonly medium: "01783fb6beadcf6f8486fff0836820ad43fab5662b812a907fe9cfdb83e9804d";
+                    readonly high: "98d16f2b7d12f4eb540d625c853e51d227933e204923e43e8b9b4176f10aca2c";
+                };
+            };
+        };
+    };
+    readonly artifacts: {
+        readonly sourceSha256: "dd39aacfece496cc6528f6acdb4f1066a848a0fb5b0961f5c70b0ba00440dc24";
+        readonly x64Sha256: "67e3624d3198e9c59e1ffafa4eca7c895dfe265d5b8bb0614cb547b68b8b93a7";
+        readonly arm64Sha256: "c07d22225ff968bc289e5ddf0981cdd5d64040eee6e3ea45da7d03e1439dea98";
+    };
+};
+/**
+ * Where the Daimon broker writes its per-turn usage ledger, and what this
+ * compiler provisions. Deliberately kept out of `DAIMON_GROK_ENGINE_BROKER`:
+ * that object's canonical bytes are digest-pinned and attested against the
+ * runtime image at compile time, so a new key there would make every pinned
+ * image fail to attest. Mirrors `TURN_USAGE_LEDGER` in
+ * `daimon/src/runtime/turnUsageLedger.ts`.
+ */
+export declare const DAIMON_GROK_TURN_USAGE_LEDGER: {
+    readonly version: "noopolis.daimon.turn-usage.v1";
+    readonly directoryPath: "/var/lib/spawnfile/daimon/usage";
+    readonly filePath: "/var/lib/spawnfile/daimon/usage/usage.jsonl";
+    readonly rotatedFilePath: "/var/lib/spawnfile/daimon/usage/usage.jsonl.1";
+    readonly directoryMode: 488;
+    readonly fileMode: 416;
+    /**
+     * Mirrors `TURN_USAGE_ROTATE_BYTES` in `daimon/src/runtime/turnUsageLedger.ts`
+     * (Spawnfile must not import from `daimon/`, so this is the Spawnfile-side
+     * copy of the same agreed number). It is a LOWER bound on the size of a
+     * rotated generation, not an upper one: the broker rotates on the append
+     * *after* the file reaches this size, so `usage.jsonl.1` is always at least
+     * this large and the line that crossed the bound overshoots it. Anything
+     * sizing a read of one generation must therefore leave headroom above this
+     * number rather than matching it (see
+     * `DEFAULT_DOCKER_PROBE_MAX_BUFFER_BYTES`).
+     */
+    readonly rotateBytes: number;
+};
+export declare const DAIMON_AGY_SUBSCRIPTION_REALM: {
+    readonly directoryMode: 448;
+    readonly durableMountPath: "/var/lib/spawnfile/daimon/agy-subscription-realm";
+    readonly fileMode: 384;
+    readonly maxUnlockBytes: 4096;
+    readonly unlockMountPath: "/var/lib/spawnfile/daimon/agy-unlock-secret";
+    readonly unlockSourceSlot: "agy-unlock-secret";
+};
+export type DaimonEngine = typeof DAIMON_ENGINE_KINDS[number];
+export type DaimonPortableEngine = keyof typeof DAIMON_ENGINE_CREDENTIALS;
+type DaimonCredentialMaterial = (typeof DAIMON_ENGINE_CREDENTIALS)[DaimonPortableEngine];
+export interface DaimonContractManifest {
+    readonly agySubscriptionRealm: typeof DAIMON_AGY_SUBSCRIPTION_REALM;
+    readonly consumedConfigFields: readonly string[];
+    readonly engineCredentialMaterial: Readonly<Record<DaimonPortableEngine, DaimonCredentialMaterial>>;
+    readonly grokSubscriptionRealm: typeof DAIMON_GROK_SUBSCRIPTION_REALM;
+    readonly grokEngineBroker: typeof DAIMON_GROK_ENGINE_BROKER;
+    readonly supportedEngineKinds: readonly DaimonEngine[];
+    readonly wakeAcceptanceTypes: readonly ["manual", "message", "schedule", "external"];
+    readonly deliverySemantics: Readonly<{
+        activeDeliveryIdempotency: "unbounded-until-terminal";
+        terminalReceiptHorizon: 2_048;
+        recovery: "at-least-once-with-stable-wake-id";
+        concurrentSameAgentTurns: false;
+        externalEffectsExactlyOnce: false;
+    }>;
+    readonly version: typeof DAIMON_CONTRACT_MANIFEST_VERSION;
+}
+export interface VerifiedDaimonContractManifest {
+    readonly digest: `sha256:${string}`;
+    readonly manifest: DaimonContractManifest;
+}
+export declare const parseDaimonContractManifest: (raw: unknown) => DaimonContractManifest;
+export declare const assertDaimonRuntimeHome: (candidate: string) => string;
+export declare const readVerifiedDaimonContractManifest: (runtimeRoot: string) => Promise<VerifiedDaimonContractManifest>;
+export {};