spawnfile 0.1.34 → 0.1.35

package/dist/audit/readAudit.d.ts

@@ -3,12 +3,12 @@ import type { AuditReport } from "./types.js";
 export declare const auditReportSchema: z.ZodObject<{
     checks: z.ZodArray<z.ZodObject<{
         category: z.ZodEnum<{
-            provenance: "provenance";
-            causal: "causal";
             container: "container";
-            control: "control";
             memory: "memory";
             network: "network";
+            provenance: "provenance";
+            causal: "causal";
+            control: "control";
         }>;
         evidence: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         id: z.ZodString;

package/dist/auth/profileStore.d.ts

@@ -1,9 +1,11 @@
-import type { AuthProfile, ImportedAuthKind, ResolvedAuthProfile } from "./types.js";
+import type { AuthProfile, ImportedAuthKind, ResolvedAuthProfile, SubscriptionRealmBinding } from "./types.js";
 export declare const createResolvedAuthProfile: (profileName: string, profile: AuthProfile) => ResolvedAuthProfile;
 export declare const loadAuthProfile: (profileName: string) => Promise<ResolvedAuthProfile | null>;
 export declare const requireAuthProfile: (profileName: string) => Promise<ResolvedAuthProfile>;
 export declare const ensureAuthProfile: (profileName: string) => Promise<ResolvedAuthProfile>;
 export declare const setAuthProfileEnv: (profileName: string, env: Record<string, string>) => Promise<ResolvedAuthProfile>;
+/** Records an engine's volume-held login on the profile (names only, never login bytes). */
+export declare const registerSubscriptionRealm: (profileName: string, engine: string, binding: SubscriptionRealmBinding) => Promise<ResolvedAuthProfile>;
 export declare const registerImportedAuth: (profileName: string, kind: ImportedAuthKind) => Promise<{
     directory: string;
     profile: ResolvedAuthProfile;

package/dist/auth/profileStore.js

@@ -4,7 +4,7 @@ import { ensurePrivateDirectory, fileExists, readUtf8File, removeDirectory, writ
 import { SpawnfileError } from "../shared/index.js";
 import { resolveAuthHome, resolveImportedAuthDirectory, resolveProfileDirectory, resolveProfilePath, resolveProfilesRoot } from "./paths.js";
 const importedAuthEntrySchema = z.object({
-    kind: z.enum(["claude-code", "codex"]),
+    kind: z.enum(["claude-code", "codex", "grok"]),
     relativePath: z.string().min(1)
 });
 const authProfileSchema = z.object({
@@ -12,9 +12,15 @@ const authProfileSchema = z.object({
     imports: z
         .object({
         "claude-code": importedAuthEntrySchema.optional(),
-        codex: importedAuthEntrySchema.optional()
+        codex: importedAuthEntrySchema.optional(),
+        grok: importedAuthEntrySchema.optional()
     })
         .default({}),
+    realms: z.record(z.string().regex(/^[a-z][a-z0-9-]*$/u), z.object({
+        realmVolume: z.string().min(1),
+        unlockVolume: z.string().min(1),
+        homeVolume: z.string().min(1).optional()
+    }).strict()).optional(),
     version: z.literal(1)
 });
 const createEmptyProfile = () => ({
@@ -35,6 +41,17 @@ export const createResolvedAuthProfile = (profileName, profile) => ({
     name: profileName,
     profileDirectory: resolveProfileDirectory(profileName),
     profilePath: resolveProfilePath(profileName),
+    ...(profile.realms && Object.keys(profile.realms).length > 0 ? { realms: structuredClone(profile.realms) } : {}),
+    version: 1
+});
+/** The stored form of a resolved profile: import paths relative to its directory again. */
+const storedProfile = (current) => ({
+    env: { ...current.env },
+    imports: Object.fromEntries(Object.entries(current.imports).map(([kind, entry]) => [
+        kind,
+        { kind: entry.kind, relativePath: path.relative(current.profileDirectory, entry.path) }
+    ])),
+    ...(current.realms ? { realms: structuredClone(current.realms) } : {}),
     version: 1
 });
 export const loadAuthProfile = async (profileName) => {
@@ -80,20 +97,13 @@ const writeProfile = async (profileName, profile) => {
 };
 export const setAuthProfileEnv = async (profileName, env) => {
     const current = (await loadAuthProfile(profileName)) ?? (await ensureAuthProfile(profileName));
-    return writeProfile(profileName, {
-        env: {
-            ...current.env,
-            ...env
-        },
-        imports: Object.fromEntries(Object.entries(current.imports).map(([kind, entry]) => [
-            kind,
-            {
-                kind: entry.kind,
-                relativePath: path.relative(current.profileDirectory, entry.path)
-            }
-        ])),
-        version: 1
-    });
+    const stored = storedProfile(current);
+    return writeProfile(profileName, { ...stored, env: { ...stored.env, ...env } });
+};
+/** Records an engine's volume-held login on the profile (names only, never login bytes). */
+export const registerSubscriptionRealm = async (profileName, engine, binding) => {
+    const stored = storedProfile((await loadAuthProfile(profileName)) ?? (await ensureAuthProfile(profileName)));
+    return writeProfile(profileName, { ...stored, realms: { ...stored.realms, [engine]: { ...binding } } });
 };
 export const registerImportedAuth = async (profileName, kind) => {
     const current = (await loadAuthProfile(profileName)) ?? (await ensureAuthProfile(profileName));
@@ -104,22 +114,13 @@ export const registerImportedAuth = async (profileName, kind) => {
     if (kind !== "grok")
         await removeDirectory(importDirectory);
     await ensurePrivateDirectory(importDirectory);
+    const stored = storedProfile(current);
     const nextProfile = {
-        env: { ...current.env },
+        ...stored,
         imports: {
-            ...Object.fromEntries(Object.entries(current.imports).map(([entryKind, entry]) => [
-                entryKind,
-                {
-                    kind: entry.kind,
-                    relativePath: path.relative(current.profileDirectory, entry.path)
-                }
-            ])),
-            [kind]: {
-                kind,
-                relativePath: path.relative(current.profileDirectory, importDirectory)
-            }
-        },
-        version: 1
+            ...stored.imports,
+            [kind]: { kind, relativePath: path.relative(current.profileDirectory, importDirectory) }
+        }
     };
     return {
         directory: importDirectory,

package/dist/auth/types.d.ts

@@ -3,9 +3,23 @@ export interface ImportedAuthEntry {
     kind: ImportedAuthKind;
     relativePath: string;
 }
+/**
+ * A login that lives in Docker volumes rather than an importable file: the
+ * engine's durable realm volume, the volume holding its unlock secret, and the
+ * volume holding the engine's login files from its runtime home (seeded into
+ * each fresh home at boot, written back after the container stops).
+ * Created once by `spawnfile auth login <engine>`; the profile records names only.
+ */
+export interface SubscriptionRealmBinding {
+    realmVolume: string;
+    unlockVolume: string;
+    /** Absent on a login recorded before home login files were kept: log in again. */
+    homeVolume?: string;
+}
 export interface AuthProfile {
     env: Record<string, string>;
     imports: Partial<Record<ImportedAuthKind, ImportedAuthEntry>>;
+    realms?: Record<string, SubscriptionRealmBinding>;
     version: 1;
 }
 export interface ResolvedAuthProfile {
@@ -18,5 +32,7 @@ export interface ResolvedAuthProfile {
     name: string;
     profileDirectory: string;
     profilePath: string;
+    /** Volume-held logins by engine id; absent means none. */
+    realms?: Record<string, SubscriptionRealmBinding>;
     version: 1;
 }

package/dist/cli/authCommands.d.ts

@@ -1,5 +1,5 @@
 import type { Command } from "commander";
 import type { CliHandlers, CliStreams } from "./runCli.js";
-type AuthCommandHandlers = Pick<CliHandlers, "importClaudeCodeAuth" | "importCodexAuth" | "importGrokAuth" | "importEnvFile" | "initializeTargetSecretSourceLifecycle" | "provisionCredentials" | "requireAuthProfile" | "syncProjectAuth">;
+type AuthCommandHandlers = Pick<CliHandlers, "importClaudeCodeAuth" | "importCodexAuth" | "importGrokAuth" | "importEnvFile" | "initializeTargetSecretSourceLifecycle" | "loginSubscriptionRealm" | "provisionCredentials" | "requireAuthProfile" | "syncProjectAuth">;
 export declare const registerAuthCommands: (program: Command, handlers: AuthCommandHandlers, streams: CliStreams, stdin: AsyncIterable<unknown>) => void;
 export {};

package/dist/cli/authCommands.js

@@ -9,10 +9,12 @@ import { envFileAliasOption, resolveEnvFileOption, runtimeEnvFileOption } from "
 const formatAuthProfileSummary = (profile) => {
     const envKeys = Object.keys(profile.env).sort();
     const importedKinds = Object.keys(profile.imports).sort();
+    const realms = Object.keys(profile.realms ?? {}).sort();
     return [
         `profile: ${profile.name}`,
         `env: ${envKeys.length > 0 ? envKeys.join(", ") : "none"}`,
-        `imports: ${importedKinds.length > 0 ? importedKinds.join(", ") : "none"}`
+        `imports: ${importedKinds.length > 0 ? importedKinds.join(", ") : "none"}`,
+        ...(realms.length > 0 ? [`logins: ${realms.join(", ")}`] : [])
     ];
 };
 const emitLines = (streams, lines) => lines.forEach((line) => streams.stdout(line));
@@ -108,6 +110,24 @@ export const registerAuthCommands = (program, handlers, streams, stdin) => {
         const profile = await handlers.importCodexAuth(options.profile, options.from);
         emitLines(streams, formatAuthProfileSummary(profile));
     });
+    authCommand
+        .command("login")
+        .description("Sign an auth profile into its own volume-held login (AGY) from this terminal")
+        .argument("<engine>", "Daimon engine whose login lives in a keyring realm, e.g. agy")
+        .option("-p, --profile <name>", "Auth profile name", "default")
+        .option("--dry-run", "Prepare the login volumes and print the login command without running it")
+        .action(async (engine, options) => {
+        if (!options.dryRun && process.stdin.isTTY !== true) {
+            throw new Error("spawnfile auth login is interactive; run it from a terminal");
+        }
+        const result = await handlers.loginSubscriptionRealm({ engine, profileName: options.profile, dryRun: options.dryRun === true });
+        emitLines(streams, [
+            ...formatAuthProfileSummary(result.profile),
+            `realm volume: ${result.binding.realmVolume}`,
+            `unlock volume: ${result.binding.unlockVolume}`,
+            ...(options.dryRun ? [`login command: ${result.command.join(" ")}`] : [])
+        ]);
+    });
     authCommand
         .command("sync")
         .description("Provision auth material a project requires into a profile")

package/dist/cli/runCli.d.ts

@@ -1,3 +1,4 @@
+import { loginSubscriptionRealm } from "../compiler/training/trial/index.js";
 import { importClaudeCodeAuth, importCodexAuth, importGrokAuth, importEnvFile, initializeTargetSecretSourceLifecycle, provisionCredentials, requireAuthProfile } from "../auth/index.js";
 import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, buildUpReceipt, clearProjectModelFallbacks, compileProject, createTrainingContext, createTrainingPlan, loadTrainingProject, resolveTrainingPlan, materializeTrainingMoment, lowerTrainingExecution, allocateTrainingOutputParent, initProject, listInitTemplates, publishProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { devStopProject, devUpProject } from "../dev/index.js";
@@ -37,6 +38,7 @@ export interface CliHandlers {
     importClaudeCodeAuth: typeof importClaudeCodeAuth;
     importCodexAuth: typeof importCodexAuth;
     importGrokAuth: typeof importGrokAuth;
+    loginSubscriptionRealm: typeof loginSubscriptionRealm;
     importEnvFile: typeof importEnvFile;
     initProject: typeof initProject;
     listInitTemplates: typeof listInitTemplates;

package/dist/cli/runCli.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { loginSubscriptionRealm } from "../compiler/training/trial/index.js";
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importGrokAuth, importEnvFile, initializeTargetSecretSourceLifecycle, provisionCredentials, requireAuthProfile } from "../auth/index.js";
 import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, buildUpReceipt, clearProjectModelFallbacks, compileProject, createTrainingContext, createTrainingPlan, loadTrainingProject, resolveTrainingPlan, materializeTrainingMoment, lowerTrainingExecution, allocateTrainingOutputParent, initProject, listInitTemplates, preflightCompilePlan, publishProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
@@ -44,7 +45,7 @@ const createDefaultHandlers = () => ({
     addAgentProject, addProjectModelFallback, addProjectSurface,
     addSubagentProject, addTeamProject, clearProjectModelFallbacks,
     importClaudeCodeAuth, importCodexAuth, importGrokAuth, importEnvFile, initializeTargetSecretSourceLifecycle,
-    provisionCredentials,
+    loginSubscriptionRealm, provisionCredentials,
     createDockerProbeGateway, exportRunArtifacts, downDeployment, inspectDockerDeployment,
     listDeploymentRecords, listHomeDeploymentRecords,
     initProject, listInitTemplates, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,

package/dist/cli/trainingBooted.d.ts

@@ -3,5 +3,7 @@ import type { RunTrainingOptions } from "./trainingExecution.js";
  * Production-booted training for a Daimon subject: the training core and the
  * grader run here, and every trial is the subject's own compiled organization
  * in its own container, sharing the run's one auth gateway (and so one login).
+ * Every subscription judgment of the run wakes one of the run's warm, tool-free
+ * judge containers on that same gateway; none reads a personal login.
  */
 export declare const runBootedTraining: (options: RunTrainingOptions) => Promise<number>;

package/dist/cli/trainingBooted.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { requireAuthProfile } from "../auth/index.js";
 import { createBootedTrialRun } from "../compiler/training/trial/index.js";
-import { createDaimonBootedAdapter } from "../runtime/daimon/training/booted/index.js";
+import { bindBootedJudges, createDaimonBootedAdapter } from "../runtime/daimon/training/booted/index.js";
 import { SpawnfileError } from "../shared/index.js";
 const failure = (message) => new SpawnfileError("runtime_error", message);
 const flag = (args, name) => {
@@ -12,6 +12,8 @@ const flag = (args, name) => {
  * Production-booted training for a Daimon subject: the training core and the
  * grader run here, and every trial is the subject's own compiled organization
  * in its own container, sharing the run's one auth gateway (and so one login).
+ * Every subscription judgment of the run wakes one of the run's warm, tool-free
+ * judge containers on that same gateway; none reads a personal login.
  */
 export const runBootedTraining = async (options) => {
     if (!options.authProfile)
@@ -29,6 +31,7 @@ export const runBootedTraining = async (options) => {
         authProfile: await requireAuthProfile(options.authProfile),
         scratchRoot: path.join(path.resolve(out), "booted-trials")
     });
+    bindBootedJudges(run);
     try {
         const { main } = await import("../runtime/trainingCli.js");
         return await main(["train", ...options.args, ...(flag(options.args, "runtime") ? [] : ["--runtime", "daimon"]), ...instructions], {
@@ -36,6 +39,7 @@ export const runBootedTraining = async (options) => {
         }, { adapter: (_runtime, adapter) => createDaimonBootedAdapter({ launcher: run, timeoutMs: adapter.timeoutMs }) });
     }
     finally {
+        bindBootedJudges(undefined);
         await run.close();
     }
 };

package/dist/compiler/containerDaimonBrokerRender.js

@@ -51,9 +51,19 @@ export const renderDaimonWorkspaceResourceSecurity = (resources, owners = { link
  * `EPERM` the moment root no longer owns the path.
  */
 export const renderDaimonUsageLedgerProvisioning = () => {
-    const { directoryPath } = DAIMON_GROK_TURN_USAGE_LEDGER;
+    const { directoryPath, filePath } = DAIMON_GROK_TURN_USAGE_LEDGER;
+    // The ledger file itself is shared too: the broker uid appends Grok rows and
+    // the organization uid appends Codex/AGY rows, and Daimon's wake fuse creates
+    // it empty as the organization uid at 0640 when absent, which leaves the
+    // broker unable to append and every Grok usage row silently lost. Root owns
+    // it first (it holds no CAP_DAC_OVERRIDE or CAP_FOWNER), then hands it to
+    // broker:organization at 0660, on every start so a reattached volume heals.
+    const owner = `${DAIMON_BROKER_UID}:${DAIMON_ORGANIZATION_UID}`;
     return [
-        `chown 0:0 ${directoryPath} && chmod 0770 ${directoryPath} && chown ${DAIMON_BROKER_UID}:${DAIMON_ORGANIZATION_UID} ${directoryPath}`,
+        `chown 0:0 ${directoryPath} && chmod 0770 ${directoryPath}`,
+        `if [ -L ${filePath} ] || { [ -e ${filePath} ] && [ ! -f ${filePath} ]; }; then echo "usage ledger ${filePath} is not a regular file" >&2; exit 1; fi`,
+        `if [ -e ${filePath} ]; then chown 0:0 ${filePath}; else (umask 077 && : > ${filePath}); fi && chmod 0660 ${filePath} && chown ${owner} ${filePath}`,
+        `chown ${owner} ${directoryPath}`,
         `setpriv --clear-groups --reuid ${DAIMON_ORGANIZATION_UID} --regid ${DAIMON_ORGANIZATION_UID} --inh-caps=-all --ambient-caps=-all --bounding-set=-all -- bash -ceu 'probe=${directoryPath}/.daimon-usage-probe; umask 007; : > "$probe"; rm "$probe"'`
     ];
 };

package/dist/compiler/containerDaimonGatewayRender.js

@@ -88,6 +88,10 @@ export const renderDaimonGatewayProvisioning = (plans) => {
         `  ${KEY_VARIABLE}=\${${DAIMON_GATEWAY_KEY_ENV}:?${DAIMON_GATEWAY_KEY_ENV} must accompany ${DAIMON_GATEWAY_URL_ENV}}`,
         // Only the runtime and broker launches below get them, as with the in-container gateway.
         `  export -n ${DAIMON_GATEWAY_URL_ENV} ${DAIMON_GATEWAY_KEY_ENV}`,
+        // Empty root-only placeholders: a brokered worker's sandbox masks these paths and refuses one that is missing.
+        ...(descriptors.some((descriptor) => descriptor.broker !== null)
+            ? [DAIMON_GATEWAY_ETC, DAIMON_GATEWAY_RUN, DAIMON_GATEWAY_BOOTSTRAP_ROOT, ...descriptors.map(daimonGatewayRealmPath)] : [])
+            .map((target) => `  if [ ! -e ${target} ]; then install -d -o root -g root -m 0700 ${target}; fi`),
         "else",
         `  ${EXTERNAL_VARIABLE}=0 ${URL_VARIABLE}=${DAIMON_GATEWAY_URL}`,
         // Rotated every start: 32 random bytes as lowercase hex, held only in this root shell.

package/dist/compiler/containerDaimonUidEntrypointRender.js

@@ -253,7 +253,9 @@ export const renderDaimonUidEntrypoint = (runtimePlans, persistentMountPaths = [
         "  if [ \"$EUID\" -eq 0 ]; then exit 1; fi",
         "  test \"$(sed -n \"s/^CapEff:[[:space:]]*//p\" /proc/self/status)\" = 0000000000000000",
         "  exec \"$@\"",
-        `' bash "\${runtime_command[@]}" &`,
+        // Explicit stdin: a non-interactive shell gives `&` jobs /dev/null, which would
+        // starve the interactive `auth <engine> login` of the operator's terminal.
+        `' bash "\${runtime_command[@]}" <&0 &`,
         "runtime_pid=$!",
         "trap - EXIT TERM INT HUP",
         "stopping=0",

package/dist/compiler/runProject.d.ts

@@ -29,6 +29,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
         name: string;
         value: string;
     };
+    command?: readonly string[];
     /** See `RuntimeAuthPreparationInput.containerCredentialUid`. */
     containerCredentialUid?: number;
     containerName?: string;
@@ -38,6 +39,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
     dockerContext?: string;
     dockerHost?: string;
     envFilePath?: string;
+    interactive?: boolean;
     network?: string;
 }) => Promise<DockerRunInvocation>;
 interface ResolvedRunDeploymentOptions {

package/dist/compiler/runProject.js

@@ -6,7 +6,7 @@ import { ensureDirectory, fileExists, removeDirectory, writeUtf8File } from "../
 import { appendDockerLabelArgs, createDockerDeploymentLabels, createDockerDeploymentUnitId, createDockerProjectLabel, dockerContextNameForTarget, dockerHostValueForTarget, normalizeDeploymentName, readDeploymentRecordFromOutput, resolveDeploymentRecordPath, verifyDockerDeploymentTarget, writeDockerDeploymentRecordForRun } from "../deployment/index.js";
 import { DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
 import { ensureNoopolisRunId, resolveNoopolisRunId } from "../runtime/index.js";
-import { DAIMON_GATEWAY_URL_ENV, isDaimonGatewayRealmMountId } from "../runtime/daimon/index.js";
+import { DAIMON_GATEWAY_URL_ENV, daimonProfileRealmVolume, isDaimonGatewayRealmMountId } from "../runtime/daimon/index.js";
 import { compileProject } from "./compileProject.js";
 import { createDefaultImageTag, resolveDockerBuildArchitecture } from "./buildProject.js";
 import { slugify } from "./helpers.js";
@@ -60,7 +60,7 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             args.push("-d", "--restart", "unless-stopped");
         }
         else {
-            args.push("--rm");
+            args.push("--rm", ...(options.interactive ? ["-it"] : []));
         }
         args.push("--name", containerName);
         if (options.network)
@@ -83,9 +83,10 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
         // reattached volume that already holds state is untouched by dropping it.
         // (Target/secrets volumes under src/target/* keep `volume-nocopy`: no
         // image content backs those paths and they must stay opaque.)
-        // An external auth gateway in the run env holds every gatewayed realm; the org mounts none.
+        // An external auth gateway holds every gatewayed realm (the org mounts none); a profile-held login reattaches its volume.
         const persistentMounts = (containerReport.persistent_mounts ?? [])
-            .filter((mount) => !env[DAIMON_GATEWAY_URL_ENV] || !isDaimonGatewayRealmMountId(mount.id));
+            .filter((mount) => !env[DAIMON_GATEWAY_URL_ENV] || !isDaimonGatewayRealmMountId(mount.id))
+            .map((mount) => ({ ...mount, volume_name: daimonProfileRealmVolume(mount.id, options.authProfile) ?? mount.volume_name }));
         for (const mount of persistentMounts) {
             args.push("--mount", `type=volume,source=${mount.volume_name},target=${mount.mount_path}`);
         }
@@ -103,7 +104,7 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
         args.push("--env-file", envFilePath);
         args.push(...(await resolveAuthMountArgs(containerReport, options.authProfile ?? null)));
         args.push(...preparedRuntimeAuth.mountArgs);
-        args.push(imageTag);
+        args.push(imageTag, ...(options.command ?? []));
         return {
             args,
             command: options.dockerCommand ?? "docker",

package/dist/compiler/runProjectAuth.js

@@ -107,6 +107,7 @@ export const assertDeclaredModelAuthSatisfied = (containerReport, authProfile, c
         throw new SpawnfileError("validation_error", `Auth profile ${authProfile.name} is missing required auth imports: ${missingImportKinds.join(", ")}`);
     }
 };
+const RUNTIME_HOME_IMPORT_KINDS = ["claude-code", "codex"];
 const getImportMountTargetName = (kind) => kind === "claude-code" ? ".claude" : ".codex";
 const createGeneratedRuntimeSecret = (secretName, generatedMoltnetSecrets) => {
     if (secretName === "OPENCLAW_GATEWAY_TOKEN" || secretName === "OPENCLAW_HOOKS_TOKEN") {
@@ -221,7 +222,9 @@ export const resolveAuthMountArgs = async (containerReport, authProfile) => {
         return [];
     }
     const args = [];
-    for (const [kind, entry] of Object.entries(authProfile.imports)) {
+    // Only runtime-home logins are bind-mounted; a Grok import belongs to the auth gateway alone.
+    for (const kind of RUNTIME_HOME_IMPORT_KINDS) {
+        const entry = authProfile.imports[kind];
         if (!entry) {
             continue;
         }

package/dist/compiler/training/rewind/contract.d.ts

@@ -17,9 +17,9 @@ export declare const materializedInputSchema: z.ZodObject<{
     id: z.ZodString;
     declaredBy: z.ZodString;
     kind: z.ZodEnum<{
-        moltnet: "moltnet";
-        memory: "memory";
         volume: "volume";
+        memory: "memory";
+        moltnet: "moltnet";
         git: "git";
         feed: "feed";
         bundle: "bundle";
@@ -81,9 +81,9 @@ export declare const materializedMomentSchema: z.ZodObject<{
         id: z.ZodString;
         declaredBy: z.ZodString;
         kind: z.ZodEnum<{
-            moltnet: "moltnet";
-            memory: "memory";
             volume: "volume";
+            memory: "memory";
+            moltnet: "moltnet";
             git: "git";
             feed: "feed";
             bundle: "bundle";
@@ -228,9 +228,9 @@ export declare const materializedMomentJsonSchema: z.core.ZodStandardJSONSchemaP
         id: z.ZodString;
         declaredBy: z.ZodString;
         kind: z.ZodEnum<{
-            moltnet: "moltnet";
-            memory: "memory";
             volume: "volume";
+            memory: "memory";
+            moltnet: "moltnet";
             git: "git";
             feed: "feed";
             bundle: "bundle";

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

@@ -1,3 +1,4 @@
+import type { ResolvedAuthProfile } from "../../../auth/index.js";
 import { type DaimonControlCall } from "../../../runtime/daimon/control.js";
 import { type UsageRecord } from "../../../runtime/usageLedger.js";
 import { type TrialDocker } from "./docker.js";
@@ -27,6 +28,8 @@ export interface TrialWake {
     usage: UsageRecord[];
     /** The engine's own newest session record, bounded; null when none exists. */
     transcript: string | null;
+    /** Per model request of this wake, the tool-call names its response carried; null where the runtime could not say. */
+    requestToolCalls: (readonly string[] | null)[];
 }
 export interface BootedTrial {
     container: string;
@@ -44,10 +47,26 @@ export interface PreparedTrial {
     runtimeRoot: string;
     engines: string[];
     agentId: string;
-    boot(gateway: TrainingGatewayAccess, options?: {
+    /**
+     * Boots the organization. `gateway` is null for an organization on no
+     * gatewayed engine; `realms` is a profile view holding only the
+     * volume-held logins (`spawnfile auth login`) this organization mounts.
+     */
+    boot(gateway: TrainingGatewayAccess | null, options?: {
         readyTimeoutMs?: number;
+        realms?: ResolvedAuthProfile;
     }): Promise<BootedTrial>;
+    /** Runs the organization's own `auth <engine> login` attached to the operator's terminal, or returns its argv on `dryRun`. */
+    login(realms: ResolvedAuthProfile, options?: {
+        dryRun?: boolean;
+    }): Promise<readonly string[]>;
     dispose(): Promise<void>;
 }
+/**
+ * Readable and collision-free: trial ids may share long prefixes. The cut can
+ * land just after a hyphen, so it is trimmed: the slug names a kebab-case
+ * deployment, which refuses a doubled hyphen.
+ */
+export declare const trialSlug: (trialId: string) => string;
 /** Compiles and builds the trial's one-agent organization under its own lineage, as production does. */
 export declare const prepareTrial: (options: TrialOptions) => Promise<PreparedTrial>;