spawnfile 0.1.34 → 0.1.35

package/dist/compiler/training/trial/launcher.js

@@ -1,44 +1,188 @@
 import { mkdir, mkdtemp } from "node:fs/promises";
 import path from "node:path";
+import { daimonGatewayedEngines } from "../../../runtime/daimon/gateway.js";
+import { getDaimonEngineDescriptor } from "../../../runtime/daimon/index.js";
 import { ensureNoopolisRunId } from "../../../runtime/index.js";
+import { SpawnfileError } from "../../../shared/index.js";
 import { prepareTrial } from "./boot.js";
 import { createTrialDocker } from "./docker.js";
-import { startTrainingGateway } from "./gateway.js";
+import { startTrainingGateway, trainingGatewayLogins } from "./gateway.js";
+import { JUDGE_INSTRUCTIONS, writeJudgeAgent } from "./judge.js";
+import { HOME_LOGIN_FILES } from "./homeLogin.js";
+import { createRealmTurns } from "./realmTurns.js";
 /**
- * One training run's trials: each boot compiles and starts the subject's
- * one-agent organization, and every trial shares the run's single auth
- * gateway, started from the first trial's image on first use.
+ * One training run's containers: each trial boot compiles and starts the
+ * subject's one-agent organization, each judge is a tool-free one-agent
+ * organization booted the same way, and all of them share the run's single
+ * auth gateway, started from the first image on first use. The gateway holds
+ * every gatewayed login of the run's auth profile, so trials and judges on
+ * any engine reach it with one key.
  */
 export const createBootedTrialRun = (options) => {
     const docker = options.docker ?? createTrialDocker();
+    const turns = options.turns ?? createRealmTurns();
+    const prepare = options.prepare ?? prepareTrial;
     const runId = ensureNoopolisRunId();
+    const logins = trainingGatewayLogins(options.authProfile);
     let gateway;
-    return {
-        boot: async ({ trialId, instructions }) => {
-            await mkdir(options.scratchRoot, { recursive: true });
-            const prepared = await prepareTrial({ agentManifestPath: options.agentManifestPath, docker, instructions, trialId,
-                directory: await mkdtemp(path.join(options.scratchRoot, "trial-")) });
-            try {
-                gateway ??= (async () => {
-                    const image = `spawnfile-training-gateway:${runId.replace(/[^A-Za-z0-9_.-]/gu, "-").slice(0, 100)}`;
-                    await docker(["tag", prepared.image, image]);
-                    return { image, gateway: await startTrainingGateway({ authProfile: options.authProfile, docker, engines: prepared.engines,
-                            image, runId, runtimeRoot: prepared.runtimeRoot }) };
-                })();
-                const booted = await prepared.boot((await gateway).gateway);
-                return { wake: booted.wake, teardown: async () => { try {
-                        await booted.teardown();
+    const judges = new Map();
+    let closed = false;
+    /** The gateway this organization needs (null: no gatewayed engine), started on first use. */
+    const gatewayFor = async (prepared) => {
+        const gatewayed = daimonGatewayedEngines(prepared.engines);
+        if (gatewayed.length === 0)
+            return null;
+        const missing = gatewayed.filter((descriptor) => !logins.includes(descriptor.id));
+        if (missing.length > 0) {
+            throw new SpawnfileError("validation_error", `Auth profile ${options.authProfile.name} has no ${missing.map(({ id }) => id).join(", ")} login; run \`spawnfile auth import <engine> --profile ${options.authProfile.name}\``);
+        }
+        gateway ??= (async () => {
+            const image = `spawnfile-training-gateway:${runId.replace(/[^A-Za-z0-9_.-]/gu, "-").slice(0, 100)}`;
+            await docker(["tag", prepared.image, image]);
+            return { image, gateway: await startTrainingGateway({ authProfile: options.authProfile, docker, engines: logins,
+                    image, runId, runtimeRoot: prepared.runtimeRoot }) };
+        })();
+        return (await gateway).gateway;
+    };
+    /**
+     * The volume-held login (`spawnfile auth login`) this organization mounts,
+     * as a profile view that carries nothing else: no env, no imports.
+     */
+    const realmFor = (prepared) => {
+        const engine = prepared.engines.find((id) => getDaimonEngineDescriptor(id)?.auth.staging === "secret-service");
+        if (engine === undefined)
+            return undefined;
+        const binding = options.authProfile.realms?.[engine];
+        // A login recorded before its home login files were kept cannot enroll a fresh home.
+        if (!binding || (HOME_LOGIN_FILES[engine] !== undefined && binding.homeVolume === undefined)) {
+            throw new SpawnfileError("validation_error", `Auth profile ${options.authProfile.name} has no ${engine} login; run \`spawnfile auth login ${engine} --profile ${options.authProfile.name}\``);
+        }
+        return { volume: binding.realmVolume, profile: { ...options.authProfile, env: {}, imports: {}, realms: { [engine]: binding } } };
+    };
+    /** Boots one container, holding its login realm's turn (if any) until the container is gone. */
+    const bootContainer = async (prepared, turn = {}) => {
+        const access = await gatewayFor(prepared);
+        const realm = realmFor(prepared);
+        const release = realm ? await turns.take(realm.volume, turn) : undefined;
+        try {
+            const booted = await prepared.boot(access, realm ? { realms: realm.profile } : {});
+            return { ...booted, teardown: async () => { try {
+                    await booted.teardown();
+                }
+                finally {
+                    release?.();
+                } } };
+        }
+        catch (error) {
+            release?.();
+            throw error;
+        }
+    };
+    const start = async (prepared, signal) => {
+        try {
+            const booted = await bootContainer(prepared, signal ? { signal } : {});
+            return { ...booted, teardown: async () => { try {
+                    await booted.teardown();
+                }
+                finally {
+                    await prepared.dispose();
+                } } };
+        }
+        catch (error) {
+            await prepared.dispose();
+            throw error;
+        }
+    };
+    /**
+     * A judge on a volume-held login takes turns with the run's trials: it stays
+     * warm while nobody else waits for the realm, and hands the turn over (its
+     * container removed) after its current judgment once someone does. Its image
+     * is built once and kept.
+     */
+    const takeTurnsJudge = (prepared) => {
+        let booted;
+        let container = "";
+        let busy = 0;
+        let evict = false;
+        const down = async () => {
+            const current = booted;
+            booted = undefined;
+            evict = false;
+            await (await current?.catch(() => undefined))?.teardown();
+        };
+        const timeoutMs = options.judgeRealmWaitMs ?? 30 * 60_000;
+        return {
+            get container() { return container; },
+            scanCredentials: async () => (await booted?.catch(() => undefined))?.scanCredentials() ?? [],
+            wake: async (text, wakeOptions) => {
+                busy++;
+                try {
+                    if (!booted) {
+                        const pending = bootContainer(prepared, { timeoutMs, ...(wakeOptions.signal ? { signal: wakeOptions.signal } : {}),
+                            onContended: () => { evict = true; if (busy === 0)
+                                void down(); } });
+                        booted = pending;
+                        pending.then((judge) => { container = judge.container; }, () => { if (booted === pending)
+                            booted = undefined; });
                     }
-                    finally {
-                        await prepared.dispose();
-                    } } };
+                    return await (await booted).wake(text, wakeOptions);
+                }
+                finally {
+                    busy--;
+                    if (evict && busy === 0)
+                        await down();
+                }
+            },
+            teardown: async () => { try {
+                await down();
             }
-            catch (error) {
+            finally {
                 await prepared.dispose();
-                throw error;
+            } }
+        };
+    };
+    const directory = async (prefix) => {
+        await mkdir(options.scratchRoot, { recursive: true });
+        return mkdtemp(path.join(options.scratchRoot, prefix));
+    };
+    return {
+        boot: async ({ trialId, instructions, signal }) => start(await prepare({
+            agentManifestPath: options.agentManifestPath, docker, instructions, trialId, directory: await directory("trial-")
+        }), signal),
+        judge: (spec) => {
+            if (closed)
+                return Promise.reject(new SpawnfileError("runtime_error", "the training run is closed"));
+            const key = JSON.stringify([spec.engine, spec.model, spec.effort ?? null]);
+            let judge = judges.get(key);
+            if (!judge) {
+                judge = (async () => {
+                    const root = await directory("judge-");
+                    const prepared = await prepare({
+                        agentManifestPath: await writeJudgeAgent(spec, path.join(root, "source")), docker, instructions: JUDGE_INSTRUCTIONS,
+                        trialId: `judge-${spec.engine}-${key}-${runId}`, directory: root
+                    });
+                    let turnTaking;
+                    try {
+                        turnTaking = realmFor(prepared) !== undefined;
+                    }
+                    catch (error) {
+                        await prepared.dispose();
+                        throw error;
+                    }
+                    return turnTaking ? takeTurnsJudge(prepared) : start(prepared);
+                })();
+                judges.set(key, judge);
+                // A failed boot is not cached: the next judgment retries it.
+                judge.catch(() => { if (judges.get(key) === judge)
+                    judges.delete(key); });
             }
+            return judge;
         },
         close: async () => {
+            closed = true;
+            const booted = await Promise.all([...judges.values()].map((judge) => judge.catch(() => undefined)));
+            judges.clear();
+            await Promise.all(booted.map((judge) => judge?.teardown().catch(() => undefined)));
             const started = await gateway?.catch(() => undefined);
             if (!started)
                 return;

package/dist/compiler/training/trial/login.d.ts

@@ -0,0 +1,35 @@
+import { type ResolvedAuthProfile, type SubscriptionRealmBinding } from "../../../auth/index.js";
+import { prepareTrial } from "./boot.js";
+import { type TrialDocker } from "./docker.js";
+export interface SubscriptionRealmLoginOptions {
+    profileName: string;
+    engine: string;
+    /** Prepare volumes and image and return the login command without running it or recording the login. */
+    dryRun?: boolean;
+    docker?: TrialDocker;
+    /** Where the throwaway login organization is compiled (default: a fresh temp directory). */
+    scratchRoot?: string;
+    /** Builds the throwaway one-agent organization the login runs in (tests only). */
+    prepare?: typeof prepareTrial;
+}
+export interface SubscriptionRealmLoginResult {
+    binding: SubscriptionRealmBinding;
+    /** The exact `docker run` argv the login uses. */
+    command: readonly string[];
+    profile: ResolvedAuthProfile;
+}
+/** The profile's volume names for an engine's volume-held login. */
+export declare const subscriptionRealmBinding: (profileName: string, engine: string) => Required<SubscriptionRealmBinding>;
+export declare const ensureSubscriptionRealmVolumes: (docker: TrialDocker, image: string, engine: string, binding: SubscriptionRealmBinding) => Promise<void>;
+/**
+ * `spawnfile auth login <engine>`: gives an auth profile its own volume-held
+ * login for an engine that keeps its login in a Daimon secret-service realm
+ * (AGY). Creates the profile's realm, unlock and home login volumes, then runs
+ * Daimon's own interactive `auth <engine> login` in a throwaway,
+ * production-booted one-agent organization (a tool-free judge) attached to the
+ * operator's terminal, keeps the engine's login files from that throwaway home
+ * in the home login volume, and records the volume names on the profile once
+ * it succeeds.
+ * Spawnfile never reads the login or the unlock secret.
+ */
+export declare const loginSubscriptionRealm: (options: SubscriptionRealmLoginOptions) => Promise<SubscriptionRealmLoginResult>;

package/dist/compiler/training/trial/login.js

@@ -0,0 +1,85 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ensureAuthProfile, registerSubscriptionRealm } from "../../../auth/index.js";
+import { getDaimonEngineDescriptor } from "../../../runtime/daimon/index.js";
+import { DAIMON_ORGANIZATION_UID } from "../../../runtime/daimon/runtimeIdentity.js";
+import { DAIMON_PROFILE_UNLOCK_FILE } from "../../../runtime/daimon/subscriptionRealms.js";
+import { SpawnfileError } from "../../../shared/index.js";
+import { slugify } from "../../helpers.js";
+import { prepareTrial } from "./boot.js";
+import { createTrialDocker } from "./docker.js";
+import { trainingGatewayRealmVolume } from "./gateway.js";
+import { JUDGE_INSTRUCTIONS, writeJudgeAgent } from "./judge.js";
+const LABEL = "spawnfile.subscription-realm";
+/** The profile's volume names for an engine's volume-held login. */
+export const subscriptionRealmBinding = (profileName, engine) => {
+    const prefix = `spawnfile-training-${slugify(profileName) || "profile"}-${engine}`;
+    return { homeVolume: `${prefix}-home`, realmVolume: trainingGatewayRealmVolume(profileName, engine), unlockVolume: `${prefix}-unlock` };
+};
+/**
+ * Creates the unlock secret inside its volume exactly once, as the organization
+ * uid Daimon checks it against (one `0600` regular file, no newline). Generated
+ * and written inside a network-less container: the bytes never reach the host.
+ * An existing secret is kept (replacing it would orphan the encrypted keyring)
+ * unless it is unsafe, which is refused.
+ */
+const UNLOCK_PROGRAM = [
+    "const fs = require('node:fs'), crypto = require('node:crypto');",
+    "const [uid, name] = process.argv.slice(1); const target = `/unlock/${name}`;",
+    "try { const entry = fs.lstatSync(target);",
+    "  if (!entry.isFile() || entry.nlink !== 1 || entry.uid !== Number(uid) || (entry.mode & 0o777) !== 0o600 || entry.size < 1) { console.error('existing unlock secret is unsafe'); process.exit(3); }",
+    "  process.exit(0);",
+    "} catch (error) { if (error.code !== 'ENOENT') throw error; }",
+    "const fd = fs.openSync(target, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);",
+    "const bytes = Buffer.from(crypto.randomBytes(32).toString('hex'));",
+    "fs.writeSync(fd, bytes); bytes.fill(0); fs.fchmodSync(fd, 0o600); fs.fsyncSync(fd); fs.fchownSync(fd, Number(uid), Number(uid)); fs.closeSync(fd);"
+].join("\n");
+export const ensureSubscriptionRealmVolumes = async (docker, image, engine, binding) => {
+    for (const volume of [binding.realmVolume, binding.unlockVolume, ...(binding.homeVolume ? [binding.homeVolume] : [])]) {
+        await docker(["volume", "create", "--label", `${LABEL}=${engine}`, volume]);
+    }
+    await docker(["run", "--rm", "--network", "none", "--user", "0:0", "--cap-drop", "ALL", "--cap-add", "CHOWN",
+        "--security-opt", "no-new-privileges", "--entrypoint", "node", "--mount", `type=volume,source=${binding.unlockVolume},target=/unlock`,
+        image, "-e", UNLOCK_PROGRAM, String(DAIMON_ORGANIZATION_UID), DAIMON_PROFILE_UNLOCK_FILE]);
+};
+/**
+ * `spawnfile auth login <engine>`: gives an auth profile its own volume-held
+ * login for an engine that keeps its login in a Daimon secret-service realm
+ * (AGY). Creates the profile's realm, unlock and home login volumes, then runs
+ * Daimon's own interactive `auth <engine> login` in a throwaway,
+ * production-booted one-agent organization (a tool-free judge) attached to the
+ * operator's terminal, keeps the engine's login files from that throwaway home
+ * in the home login volume, and records the volume names on the profile once
+ * it succeeds.
+ * Spawnfile never reads the login or the unlock secret.
+ */
+export const loginSubscriptionRealm = async (options) => {
+    const descriptor = getDaimonEngineDescriptor(options.engine);
+    if (descriptor?.auth.staging !== "secret-service") {
+        throw new SpawnfileError("validation_error", `Engine ${options.engine} has no volume-held login; use \`spawnfile auth import ${options.engine}\``);
+    }
+    const docker = options.docker ?? createTrialDocker();
+    const current = await ensureAuthProfile(options.profileName);
+    // An earlier login keeps its volumes; one recorded before home login files were kept gains its home volume.
+    const binding = { ...subscriptionRealmBinding(current.name, options.engine), ...current.realms?.[options.engine] };
+    const realms = { ...current, env: {}, imports: {}, realms: { [options.engine]: binding } };
+    const scratch = options.scratchRoot ?? os.tmpdir();
+    await mkdir(scratch, { recursive: true });
+    const root = await mkdtemp(path.join(scratch, "spawnfile-auth-login-"));
+    let prepared;
+    try {
+        prepared = await (options.prepare ?? prepareTrial)({
+            agentManifestPath: await writeJudgeAgent({ engine: options.engine, model: "default" }, path.join(root, "source")),
+            directory: root, docker, instructions: JUDGE_INSTRUCTIONS, trialId: `login-${options.engine}-${current.name}`
+        });
+        await ensureSubscriptionRealmVolumes(docker, prepared.image, options.engine, binding);
+        const command = await prepared.login(realms, { dryRun: options.dryRun === true });
+        const profile = options.dryRun ? current : await registerSubscriptionRealm(current.name, options.engine, binding);
+        return { binding, command, profile };
+    }
+    finally {
+        await prepared?.dispose();
+        await rm(root, { recursive: true, force: true });
+    }
+};

package/dist/compiler/training/trial/realmTurns.d.ts

@@ -0,0 +1,20 @@
+/** Gives the turn back; idempotent. */
+export type ReleaseRealmTurn = () => void;
+export interface RealmTurnOptions {
+    /** Called once on the holder when another caller starts waiting: a warm holder should hand the turn over. */
+    onContended?: () => void;
+    /** Bound on the wait; on expiry the caller is refused instead of waiting forever. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * First-come turns on exclusive login realms, one holder per realm at a time.
+ * An engine whose login is one realm held under an exclusive lock (Daimon's
+ * AGY keyring, `flock` on `.daimon-lease`) admits one container per login:
+ * every container of a run that mounts that realm takes a turn here first, so
+ * a second container never boots into the lock and dies at readiness.
+ */
+export interface RealmTurns {
+    take(realm: string, options?: RealmTurnOptions): Promise<ReleaseRealmTurn>;
+}
+export declare const createRealmTurns: () => RealmTurns;

package/dist/compiler/training/trial/realmTurns.js

@@ -0,0 +1,69 @@
+import { SpawnfileError } from "../../../shared/index.js";
+export const createRealmTurns = () => {
+    const realms = new Map();
+    const release = (key, state) => {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = state.queue.shift();
+            if (!next) {
+                realms.delete(key);
+                return;
+            }
+            state.holder = next.options;
+            state.contended = false;
+            next.grant();
+            if (state.queue.length > 0)
+                notify(state);
+        };
+    };
+    const notify = (state) => {
+        if (state.contended)
+            return;
+        state.contended = true;
+        state.holder?.onContended?.();
+    };
+    return {
+        take: (key, options = {}) => {
+            if (options.signal?.aborted)
+                return Promise.reject(new SpawnfileError("runtime_error", `cancelled waiting for login realm ${key}`));
+            const state = realms.get(key);
+            if (!state) {
+                const fresh = { holder: options, contended: false, queue: [] };
+                realms.set(key, fresh);
+                return Promise.resolve(release(key, fresh));
+            }
+            return new Promise((resolve, reject) => {
+                let timer;
+                const leave = (message) => {
+                    const index = state.queue.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    state.queue.splice(index, 1);
+                    if (timer)
+                        clearTimeout(timer);
+                    options.signal?.removeEventListener("abort", onAbort);
+                    reject(new SpawnfileError("runtime_error", message));
+                };
+                const onAbort = () => leave(`cancelled waiting for login realm ${key}`);
+                const waiter = {
+                    options,
+                    grant: () => {
+                        if (timer)
+                            clearTimeout(timer);
+                        options.signal?.removeEventListener("abort", onAbort);
+                        resolve(release(key, state));
+                    }
+                };
+                state.queue.push(waiter);
+                if (options.timeoutMs !== undefined) {
+                    timer = setTimeout(() => leave(`login realm ${key} stayed held by another container for ${options.timeoutMs}ms; one login admits one container at a time`), options.timeoutMs);
+                }
+                options.signal?.addEventListener("abort", onAbort, { once: true });
+                notify(state);
+            });
+        }
+    };
+};

package/dist/manifest/renderSpawnfile.js

@@ -31,7 +31,8 @@ const orderModelTarget = (target) => {
         ["provider", target.provider],
         ["name", target.name],
         ["auth", orderModelEntryAuth(target.auth)],
-        ["endpoint", target.endpoint]
+        ["endpoint", target.endpoint],
+        ["reasoning_effort", target.reasoning_effort]
     ]);
 };
 const orderExecution = (execution) => {

package/dist/runtime/daimon/config.js

@@ -2,7 +2,7 @@ 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 { daimonGatewayedSubscriptionRealms } 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_TURN_USAGE_LEDGER } from "./contractManifest.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;
@@ -315,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/engineDescriptors.generated.d.ts

@@ -1,4 +1,4 @@
-export declare const DAIMON_ENGINE_DESCRIPTOR_SOURCE_COMMIT: "a42a2b23722eadc44874e8caf117d17237e1095f";
+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,4 +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 = "a42a2b23722eadc44874e8caf117d17237e1095f";
+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 } } } };

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

@@ -3,4 +3,4 @@ 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';
+export { daimonProfileRealmVolume, daimonSubscriptionRealmMountId, isDaimonGatewayRealmMountId } from './subscriptionRealms.js';

package/dist/runtime/daimon/index.js

@@ -3,4 +3,4 @@ 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';
+export { daimonProfileRealmVolume, daimonSubscriptionRealmMountId, isDaimonGatewayRealmMountId } from './subscriptionRealms.js';

package/dist/runtime/daimon/runAuth.js

@@ -7,6 +7,7 @@ import { SpawnfileError } from "../../shared/index.js";
 import { assertDaimonRuntimeHome, DAIMON_ORGANIZATION_RUNTIME_CONFIG_VERSIONS } from "./contractManifest.js";
 import { DAIMON_ENGINE_DESCRIPTORS, DAIMON_ENGINES, DAIMON_PORTABLE_ENGINE_ID, DAIMON_SECRET_SERVICE_ENGINE_ID, getDaimonEngineDescriptor } from "./engines.js";
 import { DAIMON_ORGANIZATION_UID } from "./runtimeIdentity.js";
+import { daimonProfileUnlockMountArgs } from "./subscriptionRealms.js";
 const MAX_OPAQUE_CREDENTIAL_BYTES = 64 * 1024;
 export const DAIMON_GROK_ACCESS_TOKEN_MIN_BYTES = 32;
 export const DAIMON_GROK_REFRESH_TOKEN_MIN_BYTES = 16;
@@ -276,6 +277,13 @@ export const prepareDaimonRuntimeAuth = async (input) => {
             const descriptor = descriptorForEngine(engine);
             if (descriptor.auth.staging !== staging)
                 continue;
+            const bound = descriptor.auth.staging === "secret-service" ? input.authProfile?.realms?.[engine] : undefined;
+            if (bound && descriptor.auth.staging === "secret-service") {
+                // The profile's own login (`spawnfile auth login`): its unlock secret lives in a
+                // volume Daimon checks in-container, so no host file and no host owner gate.
+                mountArgs.push(...daimonProfileUnlockMountArgs(bound.unlockVolume, descriptor.auth.realm.unlockMountPath));
+                continue;
+            }
             const source = daimonSourcePathForEngine(engine, process.env, input.authProfile);
             if (descriptor.auth.staging === "portable-realm") {
                 const ownerUid = await assertSafeDaimonSourceFile(source, engine, descriptor.auth.maxCredentialBytes, engine);

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

@@ -1,3 +1,21 @@
+import type { ResolvedAuthProfile } from "../../auth/index.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.
+ */
+export declare const daimonSubscriptionRealmMountId: (engine: string) => string;
+/** The file inside a profile's unlock volume that is mounted as the realm unlock secret. */
+export declare const DAIMON_PROFILE_UNLOCK_FILE = "unlock";
+/**
+ * The volume a compiled realm mount reattaches when the selected auth profile
+ * holds that engine's login (`spawnfile auth login <engine>`): the profile's
+ * realm volume instead of the deployment-lineage one.
+ */
+export declare const daimonProfileRealmVolume: (mountId: string, profile: Pick<ResolvedAuthProfile, "realms"> | null | undefined) => string | undefined;
+/** The read-only mount of a profile's unlock secret at the engine's declared unlock path. */
+export declare const daimonProfileUnlockMountArgs: (unlockVolume: string, unlockMountPath: string) => string[];
 /**
  * Whether a compiled persistent mount is a gatewayed realm. An organization
  * booted against an external gateway (`DAIMON_GATEWAY_URL` at boot) mounts

package/dist/runtime/daimon/subscriptionRealms.js

@@ -6,7 +6,20 @@ import { DAIMON_ENGINES } from "./engines.js";
  * 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`;
+export const daimonSubscriptionRealmMountId = (engine) => `daimon-${engine}-subscription-realm`;
+const realmMountId = daimonSubscriptionRealmMountId;
+/** The file inside a profile's unlock volume that is mounted as the realm unlock secret. */
+export const DAIMON_PROFILE_UNLOCK_FILE = "unlock";
+/**
+ * The volume a compiled realm mount reattaches when the selected auth profile
+ * holds that engine's login (`spawnfile auth login <engine>`): the profile's
+ * realm volume instead of the deployment-lineage one.
+ */
+export const daimonProfileRealmVolume = (mountId, profile) => Object.entries(profile?.realms ?? {}).find(([engine]) => realmMountId(engine) === mountId)?.[1].realmVolume;
+/** The read-only mount of a profile's unlock secret at the engine's declared unlock path. */
+export const daimonProfileUnlockMountArgs = (unlockVolume, unlockMountPath) => [
+    "--mount", `type=volume,source=${unlockVolume},target=${unlockMountPath},volume-subpath=${DAIMON_PROFILE_UNLOCK_FILE},readonly`
+];
 /**
  * Whether a compiled persistent mount is a gatewayed realm. An organization
  * booted against an external gateway (`DAIMON_GATEWAY_URL` at boot) mounts

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

@@ -1,4 +1,4 @@
-import type { SubjectAdapter } from '../../../../training/index.js';
+import type { SubjectAdapter, Usage } 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. */
@@ -17,6 +17,8 @@ export interface BootedWake {
     text: string;
     usage: readonly BootedUsageRow[];
     transcript: string | null;
+    /** Per model request, the tool-call names its response carried; null where the runtime could not say. */
+    requestToolCalls?: readonly (readonly string[] | null)[];
 }
 export interface BootedTrialHandle {
     wake(text: string, options: {
@@ -38,6 +40,8 @@ export interface BootedAdapterOptions {
     launcher: BootedTrialLauncher;
     timeoutMs: number;
 }
+/** Ledger rows to `Usage`; no rows means unmetered, never zero. */
+export declare const bootedUsage: (rows: readonly BootedUsageRow[]) => Usage | null;
 /**
  * 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