spawnfile 0.1.33 → 0.1.35

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 { daimonProfileRealmVolume, daimonSubscriptionRealmMountId, 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 { daimonProfileRealmVolume, daimonSubscriptionRealmMountId, 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";
@@ -6,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;
@@ -268,22 +270,31 @@ 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)
                 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);
                 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,33 @@
-export declare const daimonPortableSubscriptionRealms: (engines: readonly string[]) => {
-    opaqueMountTargets: "/var/lib/spawnfile/daimon/codex-bootstrap-auth"[];
+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
+ * 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,40 @@
-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.
+ */
+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
+ * 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,50 @@
+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. */
+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;
+    /** 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: {
+        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;
+}
+/** 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
+ * recorded (receipt, usage ledger, engine transcript).
+ */
+export declare function createDaimonBootedAdapter(options: BootedAdapterOptions): SubjectAdapter;

package/dist/runtime/daimon/training/booted/adapter.js

@@ -0,0 +1,60 @@
+export const BOOTED_ADAPTER_ID = 'daimon-booted';
+export const BOOTED_EVIDENCE_SCHEMA = 'spawnfile.training.daimon-booted.wake.v1';
+/** Ledger rows to `Usage`; no rows means unmetered, never zero. */
+export const bootedUsage = (rows) => rows.length === 0 ? null : {
+    inputTokens: rows.reduce((sum, row) => sum + row.input, 0),
+    cachedInputTokens: rows.reduce((sum, row) => sum + row.cache_read, 0),
+    outputTokens: rows.reduce((sum, row) => sum + row.output, 0),
+    reasoningTokens: null,
+    notionalUsd: rows.reduce((sum, row) => sum + row.notional_usd, 0),
+    source: 'daimon-turn-usage-ledger',
+};
+/**
+ * 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 function createDaimonBootedAdapter(options) {
+    return {
+        id: BOOTED_ADAPTER_ID,
+        capabilities: { toolTrace: 'none', liveObservations: false, cancellation: 'native-handle', multiTurn: true,
+            resources: ['instructions'], readIsolation: 'none', protectedPaths: false,
+            isolation: 'One production-booted organization container per trial; the subscription login stays in the run auth gateway.' },
+        async start(input) {
+            const trial = await options.launcher.boot({ trialId: input.trialId, instructions: input.instructions, signal: input.signal });
+            const source = `${BOOTED_ADAPTER_ID}:${input.trialId}`;
+            let seq = 0;
+            let stopped;
+            const emit = (wakeId, value) => input.onObservation({ id: `${source}:${++seq}`, source, seq, trialId: input.trialId, wakeId, timestamp: new Date().toISOString(), ...value });
+            const stop = (reason) => stopped ??= trial.teardown().then(() => ({ state: 'acknowledged', scope: 'native-handle', quiescence: 'confirmed', remoteWork: 'unknown', reason, detail: 'trial organization container removed' }), (error) => ({ state: 'unknown', scope: 'native-handle', quiescence: 'unknown', remoteWork: 'unknown', reason, detail: error instanceof Error ? error.message : String(error) }));
+            return {
+                stop,
+                async run(turn, signal) {
+                    if (stopped)
+                        throw new Error('trial organization was already stopped');
+                    const wake = await trial.wake(turn.text, { deliveryId: `${input.trialId}:${turn.id}`, timeoutMs: options.timeoutMs, signal: signal ?? input.signal });
+                    const usage = bootedUsage(wake.usage);
+                    if (wake.text)
+                        await emit(turn.id, { type: 'output', text: wake.text });
+                    if (usage)
+                        await emit(turn.id, { type: 'usage', usage });
+                    if (wake.transcript)
+                        await emit(turn.id, { type: 'diagnostic', native: { schema: BOOTED_EVIDENCE_SCHEMA, transcript: wake.transcript } });
+                    const status = wake.state === 'completed' ? 'completed' : wake.state === 'stopped' ? 'cancelled' : 'failed';
+                    return {
+                        status, text: wake.text, usage,
+                        evidence: { adapterId: BOOTED_ADAPTER_ID, payload: { schema: BOOTED_EVIDENCE_SCHEMA, acceptanceId: wake.acceptanceId,
+                                executionId: wake.executionId, state: wake.state, code: wake.code } },
+                        coverage: [
+                            { channel: 'output', completeness: wake.state === 'completed' ? 'complete' : 'partial', ordering: 'none' },
+                            { channel: 'usage', completeness: usage === null ? 'absent' : wake.usage.every((row) => row.complete) ? 'complete' : 'partial', ordering: 'none' },
+                            { channel: 'tools', completeness: 'absent', ordering: 'none' },
+                        ],
+                        ...(status === 'completed' ? {} : { error: `trial wake ${wake.state}${wake.code ? ` (${wake.code})` : ''}` }),
+                    };
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=adapter.js.map

package/dist/runtime/daimon/training/booted/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../../../src/runtime/daimon/training/booted/adapter.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+export { BOOTED_ADAPTER_ID, BOOTED_EVIDENCE_SCHEMA, bootedUsage, createDaimonBootedAdapter } from './adapter.js';
+export type { BootedAdapterOptions, BootedTrialHandle, BootedTrialLauncher, BootedUsageRow, BootedWake } from './adapter.js';
+export { bindBootedJudges, createBootedJudgeInference, transcriptToolActivity } from './judge.js';
+export type { BootedJudgeLauncher, BootedJudgeOptions, BootedJudgeSpec } from './judge.js';

package/dist/runtime/daimon/training/booted/index.js

@@ -0,0 +1,3 @@
+export { BOOTED_ADAPTER_ID, BOOTED_EVIDENCE_SCHEMA, bootedUsage, createDaimonBootedAdapter } from './adapter.js';
+export { bindBootedJudges, createBootedJudgeInference, transcriptToolActivity } from './judge.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/daimon/training/booted/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/runtime/daimon/training/booted/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEjH,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,39 @@
+import type { InferenceProvider } from '../../../../training/index.js';
+import { type BootedWake } from './adapter.js';
+/** One judge identity: the engine, and the model and effort its compiled organization pins. */
+export interface BootedJudgeSpec {
+    engine: string;
+    model: string;
+    effort?: string;
+}
+/** The run's warm judges: one booted container per judge identity, woken once per judgment. */
+export interface BootedJudgeLauncher {
+    judge(spec: BootedJudgeSpec): Promise<{
+        wake(text: string, options: {
+            deliveryId: string;
+            timeoutMs: number;
+            signal?: AbortSignal;
+        }): Promise<BootedWake>;
+    }>;
+}
+/**
+ * Composition binds the training run's judge launcher for the run's duration
+ * (`spawnfile train` runs one run per process). Providers resolve it per
+ * judgment, so grader and model registries stay static data.
+ */
+export declare function bindBootedJudges(launcher: BootedJudgeLauncher | undefined): void;
+export interface BootedJudgeOptions {
+    engine: string;
+    effort?: string;
+    timeoutMs?: number;
+}
+export declare function transcriptToolActivity(transcript: string): string[];
+/**
+ * The one subscription inference path of a training run: each judgment is
+ * one wake of the run's warm, tool-free judge organization for this engine,
+ * whose login lives only in the run's auth gateway (or the engine's own
+ * realm). The reply is validated against the requested schema after the
+ * wake. A wake whose transcript or per-request tool record shows any tool
+ * activity is refused, and so is one that left no evidence either way.
+ */
+export declare function createBootedJudgeInference(options: BootedJudgeOptions): InferenceProvider;

package/dist/runtime/daimon/training/booted/judge.js

@@ -0,0 +1,122 @@
+import { randomUUID } from 'node:crypto';
+import { InferenceFailure, validateInferenceResponse, validateInferenceSchema } from '../../../../training/index.js';
+import { bootedUsage } from './adapter.js';
+let bound;
+/**
+ * Composition binds the training run's judge launcher for the run's duration
+ * (`spawnfile train` runs one run per process). Providers resolve it per
+ * judgment, so grader and model registries stay static data.
+ */
+export function bindBootedJudges(launcher) { bound = launcher; }
+/**
+ * Structured records of a wake transcript that are not a message or
+ * reasoning: any other item kind is tool activity, including future native
+ * tool families. Engine-neutral: it reads record and item kinds only.
+ */
+const TEXT_KINDS = /^(message|reasoning|agent_message|agent_reasoning|user_message|text|thinking)$/u;
+const TOOL_KINDS = /tool|function|shell|exec|command|mcp|web_search|patch|file_change|search_tool|use_tool|call/iu;
+export function transcriptToolActivity(transcript) {
+    const found = new Set();
+    for (const line of transcript.split('\n')) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            found.add('unparseable-record');
+            continue;
+        }
+        if (record === null || typeof record !== 'object')
+            continue;
+        const visit = (value, depth) => {
+            if (depth > 3 || value === null || typeof value !== 'object' || Array.isArray(value))
+                return;
+            const entry = value;
+            const kind = entry['type'];
+            if (typeof kind === 'string' && !TEXT_KINDS.test(kind) && TOOL_KINDS.test(kind))
+                found.add(kind);
+            for (const key of ['payload', 'item', 'message', 'content']) {
+                const nested = entry[key];
+                if (Array.isArray(nested))
+                    nested.forEach(child => visit(child, depth + 1));
+                else
+                    visit(nested, depth + 1);
+            }
+        };
+        visit(record, 0);
+    }
+    return [...found].sort();
+}
+function wakeFailure(wake) {
+    if (wake.state === 'timeout')
+        return 'timeout';
+    if (wake.state === 'stopped')
+        return 'cancelled';
+    const evidence = `${wake.code ?? ''} ${wake.text}`;
+    if (/auth_stale|unauthorized|authentication|sign in|login|401|403/iu.test(evidence))
+        return 'authentication';
+    if (/quota|usage limit|rate limit|429|402/iu.test(evidence))
+        return 'quota';
+    return 'unavailable';
+}
+/**
+ * The one subscription inference path of a training run: each judgment is
+ * one wake of the run's warm, tool-free judge organization for this engine,
+ * whose login lives only in the run's auth gateway (or the engine's own
+ * realm). The reply is validated against the requested schema after the
+ * wake. A wake whose transcript or per-request tool record shows any tool
+ * activity is refused, and so is one that left no evidence either way.
+ */
+export function createBootedJudgeInference(options) {
+    const route = `${options.engine}-subscription`;
+    return {
+        id: route,
+        capabilities: { tools: 'disabled', billing: 'subscription', temperature: false, seed: false },
+        async generate(request) {
+            validateInferenceSchema(request.responseSchema);
+            if (!request.prompt.trim() || !request.model.trim() || request.temperature !== undefined || request.seed !== undefined) {
+                throw new InferenceFailure('unsupported', `Invalid ${route} inference controls`);
+            }
+            if (request.signal?.aborted)
+                throw new InferenceFailure('cancelled', `${route} cancelled before the wake`);
+            if (!bound)
+                throw new InferenceFailure('unavailable', 'Subscription judges run only as booted containers inside `spawnfile train --auth-profile <name>`');
+            const evidence = { responseModel: null, responseRoute: route };
+            const judge = await bound.judge({ engine: options.engine, model: request.model, ...(options.effort === undefined ? {} : { effort: options.effort }) })
+                .catch((error) => { throw new InferenceFailure('unavailable', `${route} judge did not boot: ${error instanceof Error ? error.message : String(error)}`, evidence); });
+            const schema = request.responseSchema === undefined ? '' : [
+                '', '', 'Reply with exactly one JSON value that validates against this JSON Schema and nothing else:',
+                JSON.stringify(request.responseSchema),
+            ].join('\n');
+            const text = `${request.system === undefined ? '' : `${request.system}\n\n`}${request.prompt}${schema}`;
+            const wake = await judge.wake(text, { deliveryId: `judge-${randomUUID()}`, timeoutMs: options.timeoutMs ?? 180_000, signal: request.signal });
+            const usage = bootedUsage(wake.usage);
+            const withUsage = { ...evidence, usage };
+            if (request.signal?.aborted)
+                throw new InferenceFailure('cancelled', `${route} judgment cancelled`, withUsage);
+            if (wake.state !== 'completed')
+                throw new InferenceFailure(wakeFailure(wake), `${route} judge wake ${wake.state}${wake.code ? ` (${wake.code})` : ''}`, withUsage);
+            const requests = wake.requestToolCalls ?? [];
+            if ((wake.transcript !== null && transcriptToolActivity(wake.transcript).length > 0) || requests.some(calls => calls !== null && calls.length > 0)) {
+                throw new InferenceFailure('protocol', `${route} attempt refused: tool-call`, { ...withUsage, detail: 'tool-call' });
+            }
+            // Proof of a tool-free wake: the engine transcript, or every model request's own tool-call record.
+            if (wake.transcript === null && (requests.length === 0 || requests.some(calls => calls === null))) {
+                throw new InferenceFailure('protocol', `${route} judge left no evidence to prove a tool-free judgment`, withUsage);
+            }
+            const reply = wake.text.trim();
+            if (!reply)
+                throw new InferenceFailure('protocol', `${route} judge replied with nothing`, withUsage);
+            try {
+                validateInferenceResponse(reply, request.responseSchema, request.responseJsonFence);
+            }
+            catch {
+                throw new InferenceFailure('invalid-response', `${route} answer violated the requested schema`, withUsage);
+            }
+            return { text: reply, model: request.model, modelBasis: 'requested-assumption', usage, route };
+        },
+    };
+}
+//# sourceMappingURL=judge.js.map