spawnfile 0.1.25 → 0.1.28

package/dist/runtime/daimon/engines.js

@@ -0,0 +1,25 @@
+import manifest from "./contract-manifest.json" with { type: "json" };
+import { parseDaimonContractManifest } from "./contractManifest.js";
+import { DAIMON_PINNED_BROKER_DESCRIPTOR, DAIMON_PINNED_PORTABLE_DESCRIPTOR, DAIMON_PINNED_SECRET_SERVICE_DESCRIPTOR } from "./engineDescriptorSchema.js";
+export const DAIMON_ENGINE_DESCRIPTORS = parseDaimonContractManifest(manifest).engines;
+export const DAIMON_ENGINES = Object.freeze(Object.keys(DAIMON_ENGINE_DESCRIPTORS).sort());
+/** Source-language omission policy stays in Spawnfile. */
+export const DAIMON_DEFAULT_ENGINE = "codex";
+export const getDaimonEngineDescriptor = (engine) => Object.hasOwn(DAIMON_ENGINE_DESCRIPTORS, engine) ? DAIMON_ENGINE_DESCRIPTORS[engine] : undefined;
+export const daimonEngineHasBroker = (engine) => getDaimonEngineDescriptor(engine)?.broker != null;
+const byStaging = (staging, preferredId) => {
+    const preferred = getDaimonEngineDescriptor(preferredId);
+    const descriptor = preferred?.auth.staging === staging ? preferred
+        : Object.values(DAIMON_ENGINE_DESCRIPTORS).find((entry) => entry.auth.staging === staging);
+    if (!descriptor)
+        throw new Error(`Daimon contract has no ${staging} engine`);
+    return descriptor;
+};
+/** Legacy wire identities retain their generated literal types, never a copied inventory. */
+export const DAIMON_PORTABLE_ENGINE_ID = byStaging("portable-file", DAIMON_PINNED_PORTABLE_DESCRIPTOR.id).id;
+export const DAIMON_BROKER_ENGINE_ID = byStaging("broker-realm", DAIMON_PINNED_BROKER_DESCRIPTOR.id).id;
+export const DAIMON_SECRET_SERVICE_ENGINE_ID = byStaging("secret-service", DAIMON_PINNED_SECRET_SERVICE_DESCRIPTOR.id).id;
+export const DAIMON_ENGINE_BROKER = byStaging("broker-realm", DAIMON_PINNED_BROKER_DESCRIPTOR.id).broker;
+// Admission additionally consumes training.subject; the declared inventory stays compatible.
+export const daimonTrainingDeclaration = { adapterId: "daimon-native", engines: DAIMON_ENGINES };
+//# sourceMappingURL=engines.js.map

package/dist/runtime/daimon/engines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engines.js","sourceRoot":"","sources":["../../../src/runtime/daimon/engines.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,0BAA0B,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAEtE,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,+BAA+B,EAAE,iCAAiC,EAAE,uCAAuC,EAA+B,MAAM,6BAA6B,CAAC;AAGvL,MAAM,CAAC,MAAM,yBAAyB,GAAG,2BAA2B,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC;AACvF,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAE3F,0DAA0D;AAC1D,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC;AAC7C,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,MAAc,EAAsC,EAAE,CAC9F,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACnG,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,MAAc,EAAW,EAAE,CAC/D,yBAAyB,CAAC,MAAM,CAAC,EAAE,MAAM,IAAI,IAAI,CAAC;AAEpD,MAAM,SAAS,GAAG,CAAC,OAAkD,EAAE,WAAmB,EAA0B,EAAE;IACpH,MAAM,SAAS,GAAG,yBAAyB,CAAC,WAAW,CAAC,CAAC;IACzD,MAAM,UAAU,GAAG,SAAS,EAAE,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS;QAChE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;IAC7F,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,OAAO,SAAS,CAAC,CAAC;IAC7E,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,6FAA6F;AAC7F,MAAM,CAAC,MAAM,yBAAyB,GAAG,SAAS,CAAC,eAAe,EAAE,iCAAiC,CAAC,EAAE,CAAC,CAAC,EAAiD,CAAC;AAC5J,MAAM,CAAC,MAAM,uBAAuB,GAAG,SAAS,CAAC,cAAc,EAAE,+BAA+B,CAAC,EAAE,CAAC,CAAC,EAA+C,CAAC;AACrJ,MAAM,CAAC,MAAM,+BAA+B,GAAG,SAAS,CAAC,gBAAgB,EAAE,uCAAuC,CAAC,EAAE,CAAC,CAAC,EAAuD,CAAC;AAC/K,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC,cAAc,EAAE,+BAA+B,CAAC,EAAE,CAAC,CAAC,MAAO,CAAC;AAE1G,6FAA6F;AAC7F,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,EAAW,CAAC"}

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

@@ -1,4 +1,5 @@
 import type { ResolvedAgentNode } from "../../compiler/types.js";
+import { type DaimonEngineDescriptor } from "./engines.js";
 import { type DaimonGrokBrokerModel, type DaimonGrokBrokerReasoningEffort } from "./contractManifest.js";
 export interface DaimonGrokModel {
     model: DaimonGrokBrokerModel;
@@ -16,4 +17,4 @@ export interface DaimonGrokModel {
  * list, a target-level `auth.method: grok`, and `reasoning_effort` — and there
  * is exactly one model (no fallback, no legacy model-level auth).
  */
-export declare const resolveDaimonGrokModel: (node: ResolvedAgentNode) => DaimonGrokModel;
+export declare const resolveDaimonGrokModel: (node: ResolvedAgentNode, descriptor?: DaimonEngineDescriptor) => DaimonGrokModel;

package/dist/runtime/daimon/grokModel.js

@@ -1,5 +1,5 @@
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_GROK_BROKER_MODELS, DAIMON_GROK_BROKER_REASONING_EFFORTS } from "./contractManifest.js";
+import { DAIMON_BROKER_ENGINE_ID, getDaimonEngineDescriptor } from "./engines.js";
 /**
  * The declared model of one brokered Daimon Grok agent.
  *
@@ -12,9 +12,12 @@ import { DAIMON_GROK_BROKER_MODELS, DAIMON_GROK_BROKER_REASONING_EFFORTS } from
  * list, a target-level `auth.method: grok`, and `reasoning_effort` — and there
  * is exactly one model (no fallback, no legacy model-level auth).
  */
-export const resolveDaimonGrokModel = (node) => {
+export const resolveDaimonGrokModel = (node, descriptor = getDaimonEngineDescriptor(DAIMON_BROKER_ENGINE_ID)) => {
+    const models = descriptor.modelSelection.models?.kind === "enum" ? descriptor.modelSelection.models.values : [];
+    const efforts = descriptor.modelSelection.reasoningEfforts;
+    const { provider, method } = descriptor.auth;
     const fail = (detail) => {
-        throw new SpawnfileError("validation_error", `Daimon Grok agent ${node.name} ${detail}; declare execution.model.primary { provider: xai, name: ${DAIMON_GROK_BROKER_MODELS.join(" | ")}, auth: { method: grok }, reasoning_effort: ${DAIMON_GROK_BROKER_REASONING_EFFORTS.join(" | ")} }`);
+        throw new SpawnfileError("validation_error", `Daimon Grok agent ${node.name} ${detail}; declare execution.model.primary { provider: ${provider}, name: ${models.join(" | ")}, auth: { method: ${method} }, reasoning_effort: ${efforts.join(" | ")} }`);
     };
     const declared = node.execution?.model;
     if (!declared)
@@ -22,12 +25,12 @@ export const resolveDaimonGrokModel = (node) => {
     if (declared.fallback?.length || declared.auth)
         fail("must declare exactly one model with target-level auth");
     const primary = declared.primary;
-    if (primary.provider !== "xai" || primary.endpoint || primary.auth?.method !== "grok")
-        fail("must use provider xai with auth.method grok");
-    if (!DAIMON_GROK_BROKER_MODELS.includes(primary.name))
+    if (primary.provider !== provider || primary.endpoint || primary.auth?.method !== method)
+        fail(`must use provider ${provider} with auth.method ${method}`);
+    if (!models.includes(primary.name))
         fail(`declares unsupported model ${primary.name}`);
     const effort = primary.reasoning_effort;
-    if (effort === undefined || !DAIMON_GROK_BROKER_REASONING_EFFORTS.includes(effort))
+    if (effort === undefined || !efforts.includes(effort))
         fail("must declare reasoning_effort");
     return { model: primary.name, reasoningEffort: effort };
 };

package/dist/runtime/daimon/grokSkillsSupport.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { parse as parseYaml } from "yaml";
 import { SpawnfileError } from "../../shared/index.js";
+import { daimonEngineHasBroker } from "./engines.js";
 import { daimonAgentSkillsFromResolved, parseDaimonAgentSkills } from "./grokWorkerSkills.js";
 /** The first Daimon whose broker accepts `skillsSha256` and renders `$GROK_HOME/skills` (noopolis/daimon-harness#55). */
 export const DAIMON_GROK_SKILLS_MIN_VERSION = "0.2.2";
@@ -41,7 +42,7 @@ const below = (version, minimum) => {
  * to start.
  */
 export const daimonGrokSkillsError = (node, engine, version = () => pinnedDaimonRuntimeVersion()) => {
-    if (engine !== "grok" || node.skills.length === 0)
+    if (!daimonEngineHasBroker(engine) || node.skills.length === 0)
         return undefined;
     try {
         parseDaimonAgentSkills(daimonAgentSkillsFromResolved(node.skills));

package/dist/runtime/daimon/grokTurnLimits.js

@@ -1,6 +1,6 @@
+import { DAIMON_ENGINE_BROKER } from "./engines.js";
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_GROK_ENGINE_BROKER } from "./contractManifest.js";
-const bounds = DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds;
+const bounds = DAIMON_ENGINE_BROKER.turnLimits.bounds;
 const fields = {
     max_requests: { target: "maxRequests", range: bounds.maxRequests },
     max_tokens: { target: "maxTokens", range: bounds.maxTokens },
@@ -44,7 +44,7 @@ export const resolveDaimonGrokTurnLimits = (value) => {
 };
 /** The registration's limits: the contract defaults, lowered or raised only by what the agent declared. */
 export const resolveDaimonGrokRegistrationLimits = (declared) => ({
-    ...DAIMON_GROK_ENGINE_BROKER.turnLimits.v1Defaults,
+    ...DAIMON_ENGINE_BROKER.turnLimits.v1Defaults,
     ...(declared?.maxRequests === undefined ? {} : { maxRequests: declared.maxRequests }),
     ...(declared?.maxTokens === undefined ? {} : { maxTokens: declared.maxTokens }),
     ...(declared?.timeoutMs === undefined ? {} : { timeoutMs: declared.timeoutMs })

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

@@ -1,6 +1,6 @@
 import { type DaimonGrokBrokerModel, type DaimonGrokBrokerReasoningEffort } from "./contractManifest.js";
-export declare const DAIMON_GROK_WORKER_SANDBOX_PROFILE: "daimon-strict";
-export declare const DAIMON_GROK_WORKER_HOME_DIRECTORY: ".grok";
+export declare const DAIMON_GROK_WORKER_SANDBOX_PROFILE: string;
+export declare const DAIMON_GROK_WORKER_HOME_DIRECTORY: string;
 /**
  * The worker `config.toml` bytes for one declared model x effort: Daimon's own
  * renderer output (vendored by `scripts/vendor-daimon-grok-contract.ts`),

package/dist/runtime/daimon/grokWorkerContract.js

@@ -1,20 +1,21 @@
+import { DAIMON_BROKER_ENGINE_ID, getDaimonEngineDescriptor, DAIMON_ENGINE_BROKER } from "./engines.js";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_GROK_ENGINE_BROKER } from "./contractManifest.js";
 import { DAIMON_GROK_WORKER_CONFIG_BYTES, DAIMON_GROK_CLOCKED_WORKER_CONFIG_BYTES } from "./grokWorkerConfigBytes.js";
-export const DAIMON_GROK_WORKER_SANDBOX_PROFILE = "daimon-strict";
-export const DAIMON_GROK_WORKER_HOME_DIRECTORY = ".grok";
+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;
 const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
 /** Characters TOML or Grok would reinterpret inside a deny entry (mirrors Daimon's refusal set). */
-const UNSAFE_DENY_PATH_CHARACTER = new RegExp("[\"\\\\\\u0000-\\u001f\\u007f*?[\\]]", "u");
+const UNSAFE_DENY_PATH_CHARACTER = new RegExp(workerDescriptor.sandbox.denyPaths.forbiddenCharacterPattern, "u");
 /**
  * The worker `config.toml` bytes for one declared model x effort: Daimon's own
  * renderer output (vendored by `scripts/vendor-daimon-grok-contract.ts`),
  * refused unless it hashes to the manifest pin the broker attests every turn.
  */
 export const resolveDaimonGrokWorkerConfig = (model, reasoningEffort, vendored = DAIMON_GROK_WORKER_CONFIG_BYTES) => {
-    const pins = DAIMON_GROK_ENGINE_BROKER.worker.configSha256;
+    const pins = DAIMON_ENGINE_BROKER.worker.configSha256;
     const pin = pins[model]?.[reasoningEffort];
     const bytes = vendored[model]?.[reasoningEffort];
     if (pin === undefined || bytes === undefined || sha256(bytes) !== pin) {
@@ -27,10 +28,10 @@ export const resolveDaimonGrokClockedWorkerConfig = (model, reasoningEffort, slo
     if (!Number.isSafeInteger(slot) || slot < 0)
         throw new SpawnfileError("compile_error", "Invalid Grok clock slot");
     const template = vendored[model]?.[reasoningEffort];
-    const pin = DAIMON_GROK_ENGINE_BROKER.worker.clockedConfigSha256[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_GROK_ENGINE_BROKER.worker.taskClock;
+    const clock = DAIMON_ENGINE_BROKER.worker.taskClock;
     const bytes = template.replaceAll(clock.timestampFilePath, clock.slotFilePattern.replace("{slot}", String(slot)));
     return { bytes, sha256: sha256(bytes) };
 };
@@ -51,8 +52,8 @@ export const renderDaimonGrokWorkerSandboxProfile = (denyPaths) => {
     }
     return [
         `[profiles.${DAIMON_GROK_WORKER_SANDBOX_PROFILE}]`,
-        'extends = "strict"',
-        "restrict_network = true",
+        `extends = ${JSON.stringify(workerDescriptor.sandbox.baseProfile)}`,
+        `restrict_network = ${workerDescriptor.sandbox.restrictNetwork}`,
         `deny = [${denied.map((entry) => JSON.stringify(entry)).join(", ")}]`,
         ""
     ].join("\n");

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

@@ -0,0 +1,4 @@
+export * from './contractManifest.js';
+export { DAIMON_PACKAGE_NAME } from './packageName.js';
+export * from './engines.js';
+export * from './contractManifestSchema.js';

package/dist/runtime/daimon/index.js

@@ -0,0 +1,5 @@
+export * from './contractManifest.js';
+export { DAIMON_PACKAGE_NAME } from './packageName.js';
+export * from './engines.js';
+export * from './contractManifestSchema.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/daimon/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,cAAc,cAAc,CAAC;AAC7B,cAAc,6BAA6B,CAAC"}

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

@@ -0,0 +1,2 @@
+/** Package identity used by generated container recipes; never a host dependency. */
+export declare const DAIMON_PACKAGE_NAME = "@noopolis/daimon";

package/dist/runtime/daimon/packageName.js

@@ -0,0 +1,3 @@
+/** 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/packageName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageName.js","sourceRoot":"","sources":["../../../src/runtime/daimon/packageName.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAC"}

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

@@ -2,9 +2,9 @@ import type { ResolvedAuthProfile } from "../../auth/index.js";
 import type { RuntimeAuthPreparationInput, RuntimeAuthPreparationResult } from "../types.js";
 export declare const DAIMON_GROK_ACCESS_TOKEN_MIN_BYTES = 32;
 export declare const DAIMON_GROK_REFRESH_TOKEN_MIN_BYTES = 16;
-export declare const DAIMON_AGY_UNLOCK_SOURCE_ENV = "SPAWNFILE_DAIMON_SOURCE_AGY_UNLOCK_SECRET";
 export declare const daimonSourceEnvironmentName: (slot: string) => string;
-export declare const daimonSourcePathForEngine: (engine: "codex" | "grok", environment?: Record<string, string | undefined>, authProfile?: ResolvedAuthProfile | null) => string;
+export declare const DAIMON_AGY_UNLOCK_SOURCE_ENV: string;
+export declare const daimonSourcePathForEngine: (engine: string, environment?: Record<string, string | undefined>, authProfile?: ResolvedAuthProfile | null) => string;
 /**
  * The uid a bind-mounted Daimon credential must be owned by on the host.
  *
@@ -42,9 +42,9 @@ export declare const isUnsafeDaimonSourceFile: (entry: DaimonSourceFileFacts, ca
  * operator can act on.
  */
 export declare const assertDaimonCredentialContainerOwner: (observedUid: number, label: string, requiredUid?: number) => void;
-export declare const assertSafeDaimonSourceFile: (sourcePath: string, label: string, maxBytes?: number, portableKind?: "codex" | "grok") => Promise<number>;
+export declare const assertSafeDaimonSourceFile: (sourcePath: string, label: string, maxBytes?: number, portableKind?: string) => Promise<number>;
 /**
- * Binds Codex leaves per agent and one Grok bootstrap leaf per organization.
+ * Binds portable leaves per agent and each declared realm once per organization.
  * Every leaf is validated from a stable descriptor and mounted read-only;
  * Daimon alone owns writable credential state and refresh reconciliation.
  */

package/dist/runtime/daimon/runAuth.js

@@ -3,33 +3,41 @@ import path from "node:path";
 import { constants } from "node:fs";
 import { chmod, lstat, mkdir, open, readFile } from "node:fs/promises";
 import { SpawnfileError } from "../../shared/index.js";
-import { DAIMON_AGY_SUBSCRIPTION_REALM, assertDaimonRuntimeHome, DAIMON_ENGINE_CREDENTIALS, DAIMON_ENGINE_KINDS, DAIMON_GROK_SUBSCRIPTION_REALM, DAIMON_ORGANIZATION_RUNTIME_CONFIG_VERSIONS } from "./contractManifest.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";
 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;
-export const DAIMON_AGY_UNLOCK_SOURCE_ENV = "SPAWNFILE_DAIMON_SOURCE_AGY_UNLOCK_SECRET";
 const fail = (message) => {
     throw new SpawnfileError("validation_error", `Daimon runtime auth ${message}`);
 };
 export const daimonSourceEnvironmentName = (slot) => `SPAWNFILE_DAIMON_SOURCE_${slot.replace(/[^A-Za-z0-9]+/g, "_").toUpperCase()}`;
+const descriptorForEngine = (engine) => getDaimonEngineDescriptor(engine) ?? fail(`has an undeclared engine ${engine}`);
+const sourceSlotForEngine = (engine) => {
+    const descriptor = descriptorForEngine(engine);
+    if (descriptor.auth.staging === "portable-file") {
+        return descriptor.credentialMaterial?.sourceSlot ?? fail(`engine ${engine} has no declared credential source slot`);
+    }
+    if (descriptor.auth.staging === "broker-realm")
+        return descriptor.auth.realm.bootstrapSourceSlot;
+    return descriptor.auth.realm.unlockSourceSlot;
+};
+export const DAIMON_AGY_UNLOCK_SOURCE_ENV = daimonSourceEnvironmentName(sourceSlotForEngine(DAIMON_SECRET_SERVICE_ENGINE_ID));
 export const daimonSourcePathForEngine = (engine, environment = process.env, authProfile = null) => {
-    const declaredSource = environment[daimonSourceEnvironmentName(engine === "grok"
-        ? DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapSourceSlot
-        : DAIMON_ENGINE_CREDENTIALS.codex.sourceSlot)]?.trim();
+    const descriptor = descriptorForEngine(engine);
+    const declaredSource = environment[daimonSourceEnvironmentName(sourceSlotForEngine(engine))]?.trim();
     if (declaredSource)
         return declaredSource;
-    if (engine === "codex" && authProfile) {
-        const imported = authProfile.imports.codex;
-        return path.join(imported?.path ?? fail("selected auth profile has no imported codex credential"), "auth.json");
+    if (descriptor.auth.staging === "secret-service") {
+        return fail(`is missing the operator-authorized ${engine.toUpperCase()} realm unlock artifact`);
     }
-    const home = os.homedir();
-    switch (engine) {
-        case "codex":
-            return path.join(process.env.CODEX_HOME || path.join(home, ".codex"), "auth.json");
-        case "grok":
-            return path.join(process.env.GROK_HOME || path.join(home, ".grok"), "auth.json");
+    // Import selection is Spawnfile policy; realm credentials remain runtime-owned.
+    if (engine === DAIMON_PORTABLE_ENGINE_ID && authProfile) {
+        const imported = authProfile.imports[DAIMON_PORTABLE_ENGINE_ID];
+        return path.join(imported?.path ?? fail(`selected auth profile has no imported ${engine} credential`), descriptor.auth.fileName);
     }
+    return path.join(environment[descriptor.homeEnvironment] || path.join(os.homedir(), descriptor.homeDirectory), descriptor.auth.fileName);
 };
 const sourceFileIdentity = (entry) => [entry.dev, entry.ino, entry.size, entry.mtimeMs, entry.uid, entry.mode, entry.nlink].join(":");
 /**
@@ -135,20 +143,28 @@ const hasRefreshableCredential = (kind, bytes) => {
     }
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
         return false;
+    const descriptor = descriptorForEngine(kind);
+    const format = descriptor.auth.format;
+    if (!format)
+        return false;
     const root = parsed;
-    const source = kind === "codex"
-        ? ((root.tokens && typeof root.tokens === "object" && !Array.isArray(root.tokens)) ? root.tokens : root)
-        : Object.entries(root).find(([key, value]) => /^https:\/\/auth\.x\.ai::/u.test(key) && value && typeof value === "object" && !Array.isArray(value))?.[1];
+    const container = format.containerKey ? root[format.containerKey] : undefined;
+    const source = format.entryKeyPattern
+        ? Object.entries(root).find(([key, value]) => new RegExp(format.entryKeyPattern, "u").test(key) && value && typeof value === "object" && !Array.isArray(value))?.[1]
+        : container && typeof container === "object" && !Array.isArray(container)
+            ? container : format.fallbackToRoot ? root : undefined;
     if (!source)
         return false;
-    const access = kind === "grok" ? source.key : source.access_token ?? source.accessToken ?? source.token;
-    const refresh = kind === "grok" ? source.refresh_token : source.refresh_token ?? source.refreshToken;
+    const access = format.accessTokenKeys.map((key) => source[key]).find((value) => value !== null && value !== undefined);
+    const refresh = format.refreshTokenKeys.map((key) => source[key]).find((value) => value !== null && value !== undefined);
     if (typeof access !== "string" || !access.trim() || typeof refresh !== "string" || !refresh.trim())
         return false;
-    if (kind === "grok" && (access.length < DAIMON_GROK_ACCESS_TOKEN_MIN_BYTES
+    // Compiler preflight retains the native broker's credential length boundary.
+    if (descriptor.auth.staging === "broker-realm" && (access.length < DAIMON_GROK_ACCESS_TOKEN_MIN_BYTES
         || refresh.length < DAIMON_GROK_REFRESH_TOKEN_MIN_BYTES))
         return false;
-    return kind !== "grok" || (typeof source.expires_at === "string" && Number.isFinite(Date.parse(source.expires_at)));
+    const expires = format.expiresAtKey ? source[format.expiresAtKey] : undefined;
+    return !format.expiresAtKey || (typeof expires === "string" && Number.isFinite(Date.parse(expires)));
 };
 const assertContainedPath = (root, candidate) => {
     const normalizedRoot = path.resolve(root);
@@ -190,7 +206,7 @@ const parseConfigAgents = (source) => {
             : undefined;
         if (typeof agent.id !== "string" || !agent.id || typeof agent.runtimeHomePath !== "string"
             || typeof engineKind !== "string"
-            || !DAIMON_ENGINE_KINDS.includes(engineKind)) {
+            || !DAIMON_ENGINES.includes(engineKind)) {
             fail("generated organization config has an invalid agent credential target");
         }
         const agentId = agent.id;
@@ -206,29 +222,27 @@ const parseConfigAgents = (source) => {
     }
     return agents.sort((left, right) => left.id.localeCompare(right.id));
 };
-const resolveCredentialSource = (agent, authProfile) => daimonSourcePathForEngine(agent.engine.kind, process.env, authProfile);
 const prepareNeutralIngress = async (outputDirectory, agent) => {
+    const credential = descriptorForEngine(agent.engine.kind).credentialMaterial;
+    const sourceRelativePath = credential?.sourceRelativePath
+        ?? fail(`engine ${agent.engine.kind} has no declared credential ingress path`);
     const rootfs = path.join(outputDirectory, "container", "rootfs");
     const runtimeHome = assertContainedPath(rootfs, path.join(rootfs, `.${agent.runtimeHomePath}`));
-    const inbound = assertContainedPath(runtimeHome, path.join(runtimeHome, path.posix.dirname(DAIMON_ENGINE_CREDENTIALS[agent.engine.kind].sourceRelativePath)));
+    const inbound = assertContainedPath(runtimeHome, path.join(runtimeHome, path.posix.dirname(sourceRelativePath)));
     await mkdir(runtimeHome, { mode: 0o700, recursive: true });
     await chmod(runtimeHome, 0o700);
     await mkdir(inbound, { mode: 0o700, recursive: true });
     await chmod(inbound, 0o700);
-    return path.posix.join(agent.runtimeHomePath, DAIMON_ENGINE_CREDENTIALS[agent.engine.kind].sourceRelativePath);
+    return path.posix.join(agent.runtimeHomePath, sourceRelativePath);
 };
 /**
- * Binds Codex leaves per agent and one Grok bootstrap leaf per organization.
+ * Binds portable leaves per agent and each declared realm once per organization.
  * Every leaf is validated from a stable descriptor and mounted read-only;
  * Daimon alone owns writable credential state and refresh reconciliation.
  */
 export const prepareDaimonRuntimeAuth = async (input) => {
     const containerCredentialUid = input.containerCredentialUid ?? DAIMON_CREDENTIAL_CONTAINER_UID;
-    const allowedSourceEnvironments = new Set([
-        ...Object.values(DAIMON_ENGINE_CREDENTIALS).map((credential) => daimonSourceEnvironmentName(credential.sourceSlot)),
-        daimonSourceEnvironmentName(DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapSourceSlot),
-        DAIMON_AGY_UNLOCK_SOURCE_ENV
-    ]);
+    const allowedSourceEnvironments = new Set(Object.keys(DAIMON_ENGINE_DESCRIPTORS).map((engine) => daimonSourceEnvironmentName(sourceSlotForEngine(engine))));
     for (const name of Object.keys(process.env)) {
         if (name.startsWith("SPAWNFILE_DAIMON_SOURCE_") && !allowedSourceEnvironments.has(name)) {
             return fail(`source slot environment ${name} is not declared by the consumed manifest`);
@@ -245,32 +259,36 @@ export const prepareDaimonRuntimeAuth = async (input) => {
     const agents = parseConfigAgents(configSource);
     const mountArgs = [];
     for (const agent of agents) {
-        if (agent.engine.kind !== "codex")
+        const descriptor = descriptorForEngine(agent.engine.kind);
+        if (descriptor.auth.staging !== "portable-file")
             continue;
-        const portableAgent = agent;
-        const sourcePath = resolveCredentialSource(portableAgent, input.authProfile);
-        const ingressPath = await prepareNeutralIngress(input.outputDirectory, portableAgent);
-        const ownerUid = await assertSafeDaimonSourceFile(sourcePath, agent.engine.kind, MAX_OPAQUE_CREDENTIAL_BYTES, "codex");
+        const sourcePath = daimonSourcePathForEngine(agent.engine.kind, process.env, input.authProfile);
+        const ingressPath = await prepareNeutralIngress(input.outputDirectory, agent);
+        const ownerUid = await assertSafeDaimonSourceFile(sourcePath, agent.engine.kind, descriptor.auth.maxCredentialBytes, agent.engine.kind);
         assertDaimonCredentialContainerOwner(ownerUid, agent.engine.kind, containerCredentialUid);
         mountArgs.push("-v", `${sourcePath}:${ingressPath}:ro`);
     }
-    // No container-owner assertion for the Grok bootstrap leaf: unlike the Codex
-    // credential and the AGY unlock secret, nothing in the organization runtime
-    // process reads it. The live Grok path goes through the engine broker, which
-    // runs under its own uid and reads only its durable realm, so pinning this
-    // leaf to the organization uid would refuse deployments that work today.
-    if (agents.some((agent) => agent.engine.kind === "grok")) {
-        const sourcePath = daimonSourcePathForEngine("grok");
-        await assertSafeDaimonSourceFile(sourcePath, "grok", DAIMON_GROK_SUBSCRIPTION_REALM.maxCredentialBytes, "grok");
-        mountArgs.push("-v", `${sourcePath}:${DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath}:ro`);
-    }
-    if (agents.some((agent) => agent.engine.kind === "agy")) {
-        const source = process.env[DAIMON_AGY_UNLOCK_SOURCE_ENV]?.trim();
-        if (!source)
-            return fail("is missing the operator-authorized AGY realm unlock artifact");
-        const ownerUid = await assertSafeDaimonSourceFile(source, "AGY realm unlock", DAIMON_AGY_SUBSCRIPTION_REALM.maxUnlockBytes);
-        assertDaimonCredentialContainerOwner(ownerUid, "AGY realm unlock", containerCredentialUid);
-        mountArgs.push("-v", `${source}:${DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath}:ro`);
+    // Realm auth is staged once per organization, in the historical mount order.
+    for (const staging of ["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 source = daimonSourcePathForEngine(engine);
+            if (descriptor.auth.staging === "broker-realm") {
+                const realm = descriptor.auth.realm;
+                // The organization uid never reads broker bootstrap material.
+                await assertSafeDaimonSourceFile(source, engine, descriptor.auth.maxCredentialBytes, engine);
+                mountArgs.push("-v", `${source}:${realm.bootstrapMountPath}:ro`);
+            }
+            else if (descriptor.auth.staging === "secret-service") {
+                const realm = descriptor.auth.realm;
+                const label = `${engine.toUpperCase()} realm unlock`;
+                const ownerUid = await assertSafeDaimonSourceFile(source, label, realm.maxUnlockBytes);
+                assertDaimonCredentialContainerOwner(ownerUid, label, containerCredentialUid);
+                mountArgs.push("-v", `${source}:${realm.unlockMountPath}:ro`);
+            }
+        }
     }
     return {
         coveredModelSecrets: [],

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

@@ -0,0 +1,2 @@
+import type { SubjectAdapterRegistration } from '../../../training/index.js';
+export declare const daimonTrainingSubject: SubjectAdapterRegistration;

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

@@ -0,0 +1,7 @@
+import { createDaimonAdapter } from './legacy/index.js';
+import { loadDaimonGrokGrantAuthority } from './native/grants/index.js';
+export const daimonTrainingSubject = {
+    create: createDaimonAdapter,
+    hostInference: { grantAuthority: loadDaimonGrokGrantAuthority },
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/runtime/daimon/training/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAC;AAGxE,MAAM,CAAC,MAAM,qBAAqB,GAA+B;IAC/D,MAAM,EAAE,mBAAmB;IAC3B,aAAa,EAAE,EAAE,cAAc,EAAE,4BAA4B,EAAE;CAChE,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { SubjectAdapter } from '../../../../training/index.js';
+import { type DaimonModule } from './public.js';
+export interface DaimonOptions {
+    command?: string;
+    authHome?: string;
+    model?: string;
+    timeoutMs?: number;
+    stopTimeoutMs?: number;
+    load?: () => Promise<DaimonModule>;
+}
+export declare function createDaimonAdapter(options?: DaimonOptions): SubjectAdapter;