spawnfile 0.1.32 → 0.1.34

package/README.md

@@ -83,7 +83,7 @@ See [container deployment](specs/CONTAINERS.md), [status](specs/STATUS.md), and
 | **OpenClaw** | OpenClaw agents and their native messaging surfaces. The default agent scaffold. |
 | **PicoClaw** | PicoClaw agents and their native messaging surfaces. |
 
-Daimon requires a pinned runtime image matching the compiler contract. The older `pi` adapter remains available for existing projects.
+Daimon requires a pinned runtime image matching the compiler contract.
 
 Portability is capability-specific: the compiler reports each feature as **supported**, **degraded**, or **unsupported**. Read that report before switching runtimes. Exact versions live in [runtimes.yaml](runtimes.yaml); the [runtime specification](specs/RUNTIMES.md) describes the adapter model.
 

package/dist/auth/trainingAuth.d.ts

@@ -1,9 +1,6 @@
 /**
- * Grok is deliberately absent. `spawnfile.training-container.v3` holds the one
- * dedicated training Grok login in a broker-owned realm volume seeded from a
- * read-only bootstrap leaf, and judges spend it through short inference grants
- * (D2). Staging a Grok credential into a shared runtime home would put a
- * rotating login where the evaluator and the image both reach it.
+ * Grok is deliberately absent: a training run's Grok login lives in its auth
+ * gateway's realm volume, never in a staged runtime home.
  */
 export type TrainingAuthProvider = "codex" | "claude";
 export interface TrainingAuthStageOptions {

package/dist/cli/devCommands.d.ts

@@ -1,3 +1,3 @@
-import { type Command } from "commander";
+import type { Command } from "commander";
 import type { CliHandlers, CliStreams } from "./runCli.js";
 export declare const registerDevCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/devCommands.js

@@ -1,11 +1,4 @@
-import { InvalidArgumentError } from "commander";
 import { envFileAliasOption, resolveEnvFileOption, runtimeEnvFileOption } from "./envFileOption.js";
-const parsePositiveIntegerOption = (value) => {
-    if (!/^[1-9]\d*$/u.test(value)) {
-        throw new InvalidArgumentError("must be a positive integer");
-    }
-    return Number(value);
-};
 export const registerDevCommands = (program, handlers, streams) => {
     const dev = program.command("dev").description("Run an interactive Spawnfile development deployment");
     dev
@@ -41,65 +34,6 @@ export const registerDevCommands = (program, handlers, streams) => {
             streams.stdout(`record: ${result.deploymentRecordPath}`);
         }
     });
-    dev
-        .command("apply")
-        .description("Hot-apply one agent into a running dev deployment")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .requiredOption("--agent <id>", "Agent id, slug, or name to hot-apply")
-        .option("--deployment <name>", "Detached deployment record name")
-        .option("--docker-command <command>", "Docker command")
-        .option("-o, --out <directory>", "Dev output directory")
-        .action(async (inputPath, options) => {
-        const result = await handlers.devApplyProject(inputPath, {
-            agent: options.agent,
-            deploymentName: options.deployment,
-            dockerCommand: options.dockerCommand,
-            outputDirectory: options.out
-        });
-        streams.stdout(`applied agent ${result.agentId}`);
-        streams.stdout(`container: ${result.containerName}`);
-        streams.stdout(`bridge: ${result.bridgeStarted ? "started" : "unchanged"}`);
-    });
-    dev
-        .command("restart")
-        .description("Reload one agent in a running dev deployment")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .requiredOption("--agent <id>", "Agent id, slug, or name to reload")
-        .option("--deployment <name>", "Detached deployment record name")
-        .option("--docker-command <command>", "Docker command")
-        .option("-o, --out <directory>", "Dev output directory")
-        .action(async (inputPath, options) => {
-        const result = await handlers.devRestartProject(inputPath, {
-            agent: options.agent,
-            deploymentName: options.deployment,
-            dockerCommand: options.dockerCommand,
-            outputDirectory: options.out
-        });
-        streams.stdout(`restarted agent ${result.agentId}`);
-        streams.stdout(`container: ${result.containerName}`);
-        streams.stdout(`bridge: ${result.bridgeStarted ? "started" : "unchanged"}`);
-    });
-    dev
-        .command("activity")
-        .description("Print the current Pi agent activity buffer from a running dev deployment")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--agent <id>", "Only show events for one agent id, slug, or name")
-        .option("--deployment <name>", "Detached deployment record name")
-        .option("--docker-command <command>", "Docker command")
-        .option("-o, --out <directory>", "Dev output directory")
-        .option("--tail <count>", "Maximum buffered events to print", parsePositiveIntegerOption)
-        .action(async (inputPath, options) => {
-        const result = await handlers.devActivityProject(inputPath, {
-            agent: options.agent,
-            deploymentName: options.deployment,
-            dockerCommand: options.dockerCommand,
-            outputDirectory: options.out,
-            tail: options.tail
-        });
-        for (const event of result.events) {
-            streams.stdout(JSON.stringify(event));
-        }
-    });
     dev
         .command("stop")
         .description("Stop the recorded dev deployment container")

package/dist/cli/runCli.d.ts

@@ -1,6 +1,6 @@
 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 { devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject } from "../dev/index.js";
+import { devStopProject, devUpProject } from "../dev/index.js";
 import { consumeImageUp } from "../distribution/index.js";
 import { createDockerProbeGateway, downDeployment, exportRunArtifacts, inspectDockerDeployment, listDeploymentRecords, listHomeDeploymentRecords } from "../deployment/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
@@ -55,9 +55,6 @@ export interface CliHandlers {
     upProject: typeof upProject;
     buildUpReceipt: typeof buildUpReceipt;
     consumeImageUp: typeof consumeImageUp;
-    devActivityProject: typeof devActivityProject;
-    devApplyProject: typeof devApplyProject;
-    devRestartProject: typeof devRestartProject;
     devStopProject: typeof devStopProject;
     devUpProject: typeof devUpProject;
     setProjectPrimaryModel: typeof setProjectPrimaryModel;

package/dist/cli/runCli.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 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";
-import { devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject } from "../dev/index.js";
+import { devStopProject, devUpProject } from "../dev/index.js";
 import { consumeImageUp } from "../distribution/index.js";
 import { createDockerProbeGateway, downDeployment, exportRunArtifacts, inspectDockerDeployment, listDeploymentRecords, listHomeDeploymentRecords } from "../deployment/index.js";
 import { errorExitCode, isSpawnfileError } from "../shared/index.js";
@@ -49,7 +49,7 @@ const createDefaultHandlers = () => ({
     listDeploymentRecords, listHomeDeploymentRecords,
     initProject, listInitTemplates, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,
     runProject, setProjectPrimaryModel, setProjectRuntime, upProject, buildUpReceipt, consumeImageUp,
-    devActivityProject, devApplyProject, devRestartProject, devStopProject, devUpProject,
+    devStopProject, devUpProject,
     setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth
 });
 const isCliStreams = (value) => {

package/dist/cli/trainCommand.js

@@ -8,14 +8,11 @@ export const registerTrainCommand = (program, handlers, streams, packageVersion,
         .description("Plan, rewind, or train one canonical agent through its declared training inputs")
         .argument("[path]", "Canonical project directory or Spawnfile path", process.cwd())
         .option("--agent <id>", "Canonical agent id or unambiguous short name (inferred for one agent)")
-        .option("--training-image <immutable-image>", "Pinned image containing the complete training environment")
-        .option("--training-config <json>", "V2 image recipe and declared inputs, or advanced v1 local bindings")
+        .option("--auth-profile <name>", "Login for production-booted Daimon trials (held by the run's auth gateway)")
         .option("--plan", "Print the resolved training authoring plan without executing training")
         .option("--materialize <example>", "Rewind an authored example into --out without running training")
         .option("--history <directory>", "Local recorded history for --materialize")
         .option("--dry-run", "Validate and estimate without compiling, authenticating or starting models")
-        .option("--repair-measurements <parent-out>", "Fork captured work into a fresh output for authorized measurement repair")
-        .option("--repair-witness <manifest>", "Explicit verified image witness for a legacy parent")
         .option("--resume", "Resume the exact persisted training experiment in --out");
     for (const name of forwarded) {
         const flag = `--${name} <value>`;
@@ -83,11 +80,9 @@ export const registerTrainCommand = (program, handlers, streams, packageVersion,
             args.push("--experiment-timeout-ms", String(timeout));
         if (options.trialTimeoutMs === undefined && plan.deadlines?.trial_ms !== undefined)
             args.push("--trial-timeout-ms", String(plan.deadlines.trial_ms));
-        const lowered = plan.targets.length > 0 ? await handlers.lowerTrainingExecution({ project, plan, args,
-            trainingConfig: options.trainingConfig, trainingImage: options.trainingImage }) : undefined;
+        const lowered = plan.targets.length > 0 ? await handlers.lowerTrainingExecution({ project, plan, args }) : undefined;
         if (lowered && options.dryRun === true) {
-            streams.stdout(JSON.stringify({ ...lowered.execution, container: { configPath: lowered.trainingConfig,
-                    declaration: lowered.declaration, ...(lowered.trainingImage ? { imageOverride: lowered.trainingImage } : {}) } }, null, 2));
+            streams.stdout(JSON.stringify(lowered.execution, null, 2));
             setExitCode(0);
             return;
         }
@@ -97,16 +92,15 @@ export const registerTrainCommand = (program, handlers, streams, packageVersion,
         if (!lowered && options.dryRun !== true && typeof options.out !== "string") {
             throw new SpawnfileError("validation_error", "Actual training requires --out when no training targets are declared");
         }
-        if (!lowered && options.dryRun !== true && typeof options.trainingConfig !== "string") {
-            throw new SpawnfileError("validation_error", "Actual training requires --training-config when no training targets are declared; host execution is disabled");
-        }
         const context = await handlers.createTrainingContext(inputPath, { agent: plan.agent.id, packageVersion });
+        // Trials are production-booted Daimon organizations: the container per trial is the isolation.
+        if (options.dryRun !== true && context.agent.runtime !== "daimon") {
+            throw new SpawnfileError("validation_error", `Actual training boots Daimon trials; agent ${context.agent.id} runs on ${context.agent.runtime}`);
+        }
         if (lowered)
             await handlers.allocateTrainingOutputParent(lowered.execution.output);
-        setExitCode(await handlers.runTraining({ context, args: lowered?.execution.args ?? args, execution: lowered?.execution,
-            repairMeasurements: options.repairMeasurements, repairWitness: options.repairWitness,
-            trainingImage: lowered?.trainingImage ?? options.trainingImage,
-            trainingConfig: lowered?.trainingConfig ?? options.trainingConfig,
+        setExitCode(await handlers.runTraining({ context, args: lowered?.execution.args ?? args,
+            authProfile: options.authProfile,
             dryRun: options.dryRun === true,
             timeoutMs: timeout + 5000, streams, signal }));
     });

package/dist/cli/trainingBooted.d.ts

@@ -0,0 +1,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).
+ */
+export declare const runBootedTraining: (options: RunTrainingOptions) => Promise<number>;

package/dist/cli/trainingBooted.js

@@ -0,0 +1,41 @@
+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 { SpawnfileError } from "../shared/index.js";
+const failure = (message) => new SpawnfileError("runtime_error", message);
+const flag = (args, name) => {
+    const index = args.indexOf(`--${name}`);
+    return index < 0 ? undefined : args[index + 1];
+};
+/**
+ * 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).
+ */
+export const runBootedTraining = async (options) => {
+    if (!options.authProfile)
+        throw failure("Production-booted Daimon training requires --auth-profile (the login its auth gateway holds)");
+    const out = flag(options.args, "out");
+    if (!out)
+        throw failure("Production-booted Daimon training requires --out");
+    const system = options.context.documents.find((document) => document.role === "system");
+    const instructions = flag(options.args, "instructions") === undefined
+        ? system ? ["--source-root", options.context.project.root, "--instructions", system.destinationPath]
+            : (() => { throw failure(`Agent ${options.context.agent.id} declares no system document to train`); })()
+        : [];
+    const run = createBootedTrialRun({
+        agentManifestPath: options.context.agent.source,
+        authProfile: await requireAuthProfile(options.authProfile),
+        scratchRoot: path.join(path.resolve(out), "booted-trials")
+    });
+    try {
+        const { main } = await import("../runtime/trainingCli.js");
+        return await main(["train", ...options.args, ...(flag(options.args, "runtime") ? [] : ["--runtime", "daimon"]), ...instructions], {
+            cwd: process.cwd(), signal: options.signal, stdout: options.streams.stdout, stderr: options.streams.stderr
+        }, { adapter: (_runtime, adapter) => createDaimonBootedAdapter({ launcher: run, timeoutMs: adapter.timeoutMs }) });
+    }
+    finally {
+        await run.close();
+    }
+};

package/dist/cli/trainingExecution.d.ts

@@ -1,17 +1,14 @@
-import { type TrainingContext, type TrainingExecution } from "../compiler/training/index.js";
+import type { TrainingContext } from "../compiler/training/index.js";
 import type { CliStreams } from "./runCli.js";
 export interface RunTrainingOptions {
     context: TrainingContext;
-    execution?: TrainingExecution;
     args: readonly string[];
     dryRun: boolean;
-    repairMeasurements?: string;
-    repairWitness?: string;
-    trainingImage?: string;
-    trainingConfig?: string;
+    /** Auth profile whose login a production-booted run's gateway holds. */
+    authProfile?: string;
     timeoutMs: number;
     streams: CliStreams;
     signal?: AbortSignal;
 }
-/** Owns image preparation/launch and invokes host estimates through the training composition. */
+/** Actual training boots production trials; dry-run estimates run on the host through the training composition. */
 export declare const runTraining: (options: RunTrainingOptions) => Promise<number>;

package/dist/cli/trainingExecution.js

@@ -1,9 +1,6 @@
 import { canonicalWireId } from '../shared/index.js';
-import { launchTrainingContainer } from "../compiler/training/container/index.js";
-import { runTrainingDocker } from "../compiler/training/container/process.js";
-import { prepareTraining } from "../compiler/training/preparation/index.js";
-import { readBoundedJson } from "../compiler/training/preparation/inputs.js";
 import { SpawnfileError } from "../shared/index.js";
+import { runBootedTraining } from "./trainingBooted.js";
 const failure = (message) => new SpawnfileError("runtime_error", message);
 const validCostReceipt = (line) => {
     try {
@@ -16,37 +13,12 @@ const validCostReceipt = (line) => {
         return false;
     }
 };
-/** Owns image preparation/launch and invokes host estimates through the training composition. */
+/** Actual training boots production trials; dry-run estimates run on the host through the training composition. */
 export const runTraining = async (options) => {
     if (options.signal?.aborted)
         return 130;
-    if (options.repairWitness && !options.repairMeasurements)
-        throw failure("--repair-witness requires --repair-measurements");
-    if (options.trainingConfig) {
-        const config = await readBoundedJson(options.trainingConfig);
-        // Image declarations go through preparation; lowered launch configurations go straight to Docker.
-        if (config.version === "spawnfile.training-container.v2" || (["spawnfile.training-container.v3", "spawnfile.training-container.v4"].includes(String(config.version)) && config.image !== undefined)) {
-            if (options.trainingImage && !options.execution)
-                throw failure("V2 owns its image declaration; --training-image is only for v1");
-            const prepared = await prepareTraining({ configPath: options.trainingConfig, context: options.context, args: options.args,
-                repairMeasurements: options.repairMeasurements, repairWitness: options.repairWitness,
-                execution: options.execution, outputOverride: options.execution?.output, imageOverride: options.execution ? options.trainingImage : undefined,
-                dryRun: options.dryRun, process: runTrainingDocker, timeoutMs: options.timeoutMs, signal: options.signal, streams: options.streams });
-            if (!("dryRun" in prepared))
-                return launchTrainingContainer({ ...prepared,
-                    timeoutMs: options.timeoutMs, signal: options.signal, streams: options.streams });
-            options.streams.stderr(`Training preparation plan ${prepared.digest}; no Docker, auth or filesystem mutations`);
-            options = { ...options, repairMeasurements: undefined, repairWitness: undefined };
-        }
-    }
-    if (options.repairMeasurements)
-        throw failure("Measurement repair requires the v2 preparation declaration");
-    if (!options.dryRun) {
-        if (!options.trainingImage || !options.trainingConfig)
-            throw failure("Actual training requires --training-image and --training-config; host execution is disabled");
-        return launchTrainingContainer({ image: options.trainingImage, configPath: options.trainingConfig,
-            context: options.context, args: options.args, execution: options.execution, timeoutMs: options.timeoutMs, streams: options.streams, signal: options.signal });
-    }
+    if (!options.dryRun)
+        return runBootedTraining(options);
     const controller = new AbortController();
     const deadline = performance.now() + options.timeoutMs;
     let active = true, lastLine = "";

package/dist/compiler/containerArtifacts.js

@@ -5,7 +5,6 @@ import { SpawnfileError } from "../shared/index.js";
 import { createMoltnetSummary, createOrganizationSummary } from "./containerArtifactSummaries.js";
 import { createEnvVariableMap, createRuntimeTargetPlans } from "./containerArtifactsPlans.js";
 import { createDockerIgnoreContent } from "./dockerBuildContext.js";
-import { createDaimonTelemetryArtifacts } from "./daimonTelemetryArtifacts.js";
 import { createRootfsFiles, renderDockerfile, renderEntrypoint, renderEnvExample } from "./containerArtifactsRender.js";
 import { createMemoryArtifactBundle } from "./memoryArtifacts.js";
 import { resolveRecordingReport } from "./recordingReport.js";
@@ -39,7 +38,6 @@ export const createContainerArtifacts = async (plan, compiledNodes, options = {}
     const localDaimonIdentityPath = process.env[DAIMON_LOCAL_RUNTIME_IDENTITY_ENV]?.trim();
     const localDaimonIdentity = localDaimonIdentityPath ? await loadLocalDaimonRuntimeIdentity(localDaimonIdentityPath) : undefined;
     const runtimePlans = await createRuntimeTargetPlans(plan, compiledNodes, options.worldBindings, options.deploymentLineage);
-    const daimonTelemetryArtifacts = createDaimonTelemetryArtifacts(plan, runtimePlans, compiledNodes);
     const envVariableMap = createEnvVariableMap(compiledNodes, runtimePlans, options.moltnet);
     const projectedWorldTokenEnvNames = [...new Set(runtimePlans.flatMap((runtimePlan) => runtimePlan.worldTokenEnvNames ?? []))].sort();
     const worldTokenEnvNames = (options.worldBindings?.artifact.bindings ?? [])
@@ -80,7 +78,6 @@ export const createContainerArtifacts = async (plan, compiledNodes, options = {}
     const persistentMountCandidates = [
         ...memoryArtifacts.mounts,
         ...workspaceResourceMounts,
-        ...daimonTelemetryArtifacts.mounts,
         ...runtimePlans.flatMap((runtimePlan) => runtimePlan.persistentMounts ?? []),
         ...((options.moltnet?.persistentMounts ?? []).map((mount) => ({
             ...(mount.declaredVolumeName ? { declared_volume_name: mount.declaredVolumeName } : {}),
@@ -109,7 +106,6 @@ export const createContainerArtifacts = async (plan, compiledNodes, options = {}
     ].sort();
     const runtimeInstances = runtimePlans
         .map((plan) => {
-        const telemetryMountIds = daimonTelemetryArtifacts.telemetryMountIdsByInstance.get(plan.id);
         return {
             ...(plan.agentPathsByNodeId ? { agent_paths: Object.fromEntries(Object.entries(plan.agentPathsByNodeId).map(([id, paths]) => [id, {
                         workspace_path: paths.workspacePath, home_path: paths.homePath, skill_roots: paths.skillRoots
@@ -126,7 +122,6 @@ export const createContainerArtifacts = async (plan, compiledNodes, options = {}
             node_ids: [...(plan.sourceIds ?? [])],
             published_port: plan.publishedPort ?? null,
             runtime: plan.runtimeName,
-            ...(telemetryMountIds ? { telemetry_mount_ids: telemetryMountIds } : {}),
             workspace_path: plan.instancePaths.workspacePath
         };
     })

package/dist/compiler/containerBackedMountRender.js

@@ -30,6 +30,8 @@
  * particular `printf %b` implementation treats `\nnn` vs `\0nnn`. For a path
  * containing none of those four characters both forms are identical.
  */
+import { DAIMON_GATEWAY_URL_ENV } from "../runtime/daimon/gateway.js";
+import { isDaimonGatewayRealmMountId } from "../runtime/daimon/subscriptionRealms.js";
 export const EPHEMERAL_STATE_OPT_OUT_ENV = "SPAWNFILE_ALLOW_EPHEMERAL_STATE";
 const shellQuote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
 const MOUNTINFO_ESCAPES = {
@@ -79,7 +81,9 @@ export const createBackedMountChecks = (mounts) => {
     }
     return [...byPath.values()]
         .sort((left, right) => left.mount_path.localeCompare(right.mount_path))
-        .map((mount) => `require_backed_mount ${shellQuote(mount.id)} ${shellQuote(escapeMountInfoPath(mount.mount_path))} ${shellQuote(mount.mount_path)} ${shellQuote(mount.volume_name)}`);
+        .map((mount) => 
+    // An organization booted against an external auth gateway mounts no realm.
+    `${isDaimonGatewayRealmMountId(mount.id) ? `[ -n "\${${DAIMON_GATEWAY_URL_ENV}:-}" ] || ` : ""}require_backed_mount ${shellQuote(mount.id)} ${shellQuote(escapeMountInfoPath(mount.mount_path))} ${shellQuote(mount.mount_path)} ${shellQuote(mount.volume_name)}`);
 };
 /**
  * The full guard — function plus checks — or nothing at all when the compile

package/dist/compiler/containerDaimonBrokerRender.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeTargetPlan } from "./containerArtifactsTypes.js";
-import { type DaimonGrokRegistration, type DaimonGrokServiceConfigOptions } from "./containerDaimonGrokWorkerRender.js";
+import { type DaimonGrokRegistration } from "./containerDaimonGrokWorkerRender.js";
 import { DAIMON_BROKER_UID, DAIMON_FIRST_WORKER_UID, DAIMON_ORGANIZATION_UID } from "../runtime/daimon/runtimeIdentity.js";
 export { DAIMON_BROKER_UID, DAIMON_FIRST_WORKER_UID, DAIMON_ORGANIZATION_UID };
 export declare const DAIMON_BROKER_EXECUTABLE = "/opt/daimon/bin/daimon-engine-broker";
@@ -59,56 +59,11 @@ export declare const renderDaimonWorkspaceResourceSecurity: (resources: Workspac
  * `EPERM` the moment root no longer owns the path.
  */
 export declare const renderDaimonUsageLedgerProvisioning: () => string[];
-/**
- * Empties a directory without touching a mount point inside it.
- *
- * `rm -rf` and `find -delete` both fail `EBUSY` on a mount point — it is
- * another filesystem's root, and its entry cannot be unlinked while it is
- * mounted. A deployment that mounts a tmpfs below a directory it later clears
- * would otherwise abort provisioning on a bare `find` failure, which is exactly
- * how a live training launch died. Mount points are left in place and descended
- * into; anything else that cannot be removed is reported by name.
- *
- * Mount points come from `/proc/self/mountinfo` field 5. The kernel
- * octal-escapes space, tab, newline and backslash there; every path this
- * compiler provisions is free of all four, and a path that is not would simply
- * fail to match and be treated as an ordinary directory.
- */
-export declare const MOUNT_AWARE_CLEAR_HELPER: string[];
 export declare const renderDaimonBrokerProvisioning: (plans: RuntimeTargetPlan[]) => string[];
 /**
  * The root broker provisioning program itself, over already-resolved
- * registrations and workspace resources.
- *
- * Production reaches it through {@link renderDaimonBrokerProvisioning}; the
- * broker-capable training container reaches it directly for its single fixed
- * slot, with `serviceOptions` pointing the turn store at per-slot tmpfs and
- * declaring the evaluator inference ledger. Both callers get byte-identical
- * credential, registration, worker-home, temp and spill provisioning — the
- * whole point of sharing it rather than writing a second root program.
- *
- * It is re-runnable: the shell wrapper removes `/etc/daimon-engine-broker` and
- * `/run/daimon-engine-broker` first, so a slot recycle replays exactly the
- * audited start-up path, credential-journal recovery included.
- */
-export declare const renderDaimonBrokerProvisioningProgram: (registrations: readonly DaimonGrokRegistration[], workspaceResources: WorkspaceSecurityResource[], serviceOptions?: DaimonGrokServiceConfigOptions, 
-/**
- * How the broker's `/etc` and `/run` roots are reset before provisioning.
- * A production organization owns both as ordinary image directories and
- * removes them outright. The training container mounts each as its own
- * tmpfs, which cannot be unlinked, so it empties them instead — the same
- * end state, reached the only way a mount point allows.
- */
-rootReset?: "remove" | "clear", 
-/** Deny targets the worker provisioning creates when absent; see `renderDaimonGrokWorkerProvisioning`. */
-optionalDenyPaths?: readonly string[], 
-/**
- * Where the broker and relay get their private `TMPDIR`. Production keeps it
- * inside the control root, which it removes and recreates exactly once. A
- * deployment that re-provisions that root — the training slot recycle — must
- * pass a path outside it: a `tmp/` inside a cleared root is a mount point in
- * the training launch, and clearing a mount point fails `EBUSY`.
+ * registrations and workspace resources. The auth gateway owns the Grok login,
+ * so the broker home is a plain turn-state folder and no bootstrap, authority or
+ * journal is staged here.
  */
-brokerTmpdir?: string, 
-/** Root-owned training deny targets, created after root reset and before worker attestation. */
-beforeWorkerProvisioning?: readonly string[]) => string[];
+export declare const renderDaimonBrokerProvisioningProgram: (registrations: readonly DaimonGrokRegistration[], workspaceResources: WorkspaceSecurityResource[]) => string[];

package/dist/compiler/containerDaimonBrokerRender.js

@@ -57,43 +57,6 @@ export const renderDaimonUsageLedgerProvisioning = () => {
         `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"'`
     ];
 };
-/**
- * Empties a directory without touching a mount point inside it.
- *
- * `rm -rf` and `find -delete` both fail `EBUSY` on a mount point — it is
- * another filesystem's root, and its entry cannot be unlinked while it is
- * mounted. A deployment that mounts a tmpfs below a directory it later clears
- * would otherwise abort provisioning on a bare `find` failure, which is exactly
- * how a live training launch died. Mount points are left in place and descended
- * into; anything else that cannot be removed is reported by name.
- *
- * Mount points come from `/proc/self/mountinfo` field 5. The kernel
- * octal-escapes space, tab, newline and backslash there; every path this
- * compiler provisions is free of all four, and a path that is not would simply
- * fail to match and be treated as an ordinary directory.
- */
-export const MOUNT_AWARE_CLEAR_HELPER = [
-    "spawnfile_mount_points=$(awk '{print $5}' /proc/self/mountinfo)",
-    "spawnfile_is_mount() { printf '%s\\n' \"$spawnfile_mount_points\" | grep -qxF \"$1\"; }",
-    "spawnfile_holds_mount() { printf '%s\\n' \"$spawnfile_mount_points\" | grep -qE \"^$(printf '%s' \"$1\" | sed 's/[][\\.*^$/]/\\\\&/g')(/|$)\"; }",
-    "spawnfile_clear_tree() {",
-    "  spawnfile_root=$1",
-    "  [ -d \"$spawnfile_root\" ] || return 0",
-    "  for spawnfile_entry in \"$spawnfile_root\"/* \"$spawnfile_root\"/.[!.]* \"$spawnfile_root\"/..?*; do",
-    "    if [ ! -e \"$spawnfile_entry\" ] && [ ! -L \"$spawnfile_entry\" ]; then continue; fi",
-    "    if spawnfile_is_mount \"$spawnfile_entry\"; then continue; fi",
-    "    if spawnfile_holds_mount \"$spawnfile_entry\"; then spawnfile_clear_tree \"$spawnfile_entry\"; continue; fi",
-    "    rm -rf \"$spawnfile_entry\" || { echo \"cannot clear $spawnfile_entry: it is in use; a mount below a provisioned root must be declared outside it\" >&2; return 1; }",
-    "  done",
-    "}",
-    // Removes the target outright, unless it is or contains a mount point: then its contents go and the
-    // mount points and the directories holding them stay, because neither can be unlinked while mounted.
-    "spawnfile_remove_tree() {",
-    "  if [ ! -e \"$1\" ] && [ ! -L \"$1\" ]; then return 0; fi",
-    "  if spawnfile_holds_mount \"$1\"; then spawnfile_clear_tree \"$1\"; return $?; fi",
-    "  rm -rf \"$1\" || { echo \"cannot remove $1: it is in use\" >&2; return 1; }",
-    "}"
-];
 export const renderDaimonBrokerProvisioning = (plans) => {
     const registrations = resolveDaimonGrokRegistrations(plans);
     if (registrations.length === 0)
@@ -115,40 +78,11 @@ export const renderDaimonBrokerProvisioning = (plans) => {
 };
 /**
  * The root broker provisioning program itself, over already-resolved
- * registrations and workspace resources.
- *
- * Production reaches it through {@link renderDaimonBrokerProvisioning}; the
- * broker-capable training container reaches it directly for its single fixed
- * slot, with `serviceOptions` pointing the turn store at per-slot tmpfs and
- * declaring the evaluator inference ledger. Both callers get byte-identical
- * credential, registration, worker-home, temp and spill provisioning — the
- * whole point of sharing it rather than writing a second root program.
- *
- * It is re-runnable: the shell wrapper removes `/etc/daimon-engine-broker` and
- * `/run/daimon-engine-broker` first, so a slot recycle replays exactly the
- * audited start-up path, credential-journal recovery included.
- */
-export const renderDaimonBrokerProvisioningProgram = (registrations, workspaceResources, serviceOptions = {}, 
-/**
- * How the broker's `/etc` and `/run` roots are reset before provisioning.
- * A production organization owns both as ordinary image directories and
- * removes them outright. The training container mounts each as its own
- * tmpfs, which cannot be unlinked, so it empties them instead — the same
- * end state, reached the only way a mount point allows.
- */
-rootReset = "remove", 
-/** Deny targets the worker provisioning creates when absent; see `renderDaimonGrokWorkerProvisioning`. */
-optionalDenyPaths, 
-/**
- * Where the broker and relay get their private `TMPDIR`. Production keeps it
- * inside the control root, which it removes and recreates exactly once. A
- * deployment that re-provisions that root — the training slot recycle — must
- * pass a path outside it: a `tmp/` inside a cleared root is a mount point in
- * the training launch, and clearing a mount point fails `EBUSY`.
+ * registrations and workspace resources. The auth gateway owns the Grok login,
+ * so the broker home is a plain turn-state folder and no bootstrap, authority or
+ * journal is staged here.
  */
-brokerTmpdir = DAIMON_BROKER_TMPDIR, 
-/** Root-owned training deny targets, created after root reset and before worker attestation. */
-beforeWorkerProvisioning = []) => {
+export const renderDaimonBrokerProvisioningProgram = (registrations, workspaceResources) => {
     const program = [
         "const crypto = require('node:crypto'); const fs = require('node:fs');",
         `const registrations = ${JSON.stringify(registrations.map(({ agentId, home, slot, uid, workspace }) => ({ agentId, home, slot, uid, workspace })))};`,
@@ -161,32 +95,17 @@ beforeWorkerProvisioning = []) => {
         "fs.writeFileSync('/etc/daimon-engine-broker/registrations.bin', Buffer.concat(records), { mode: 0o400, flag: 'wx' });",
         "fs.chownSync('/etc/daimon-engine-broker/registrations.bin', 0, 0); fs.chmodSync('/etc/daimon-engine-broker/registrations.bin', 0o400);",
         `fs.mkdirSync('${DAIMON_BROKER_REALM}', { recursive: true, mode: 0o700 }); fs.chownSync('${DAIMON_BROKER_REALM}', 0, 0); fs.chmodSync('${DAIMON_BROKER_REALM}', 0o700);`,
-        // The usage ledger directory itself is provisioned unconditionally by
-        // `renderDaimonUsageLedgerProvisioning` (every Daimon organization writes
-        // here, not just Grok ones) before this script's caller reaches the
-        // broker startup this function guards; this script only ever reads the
-        // path below, for the sandbox denylist.
-        `const bootstrap = '/var/lib/spawnfile/daimon/grok-bootstrap-auth', authority = '${DAIMON_BROKER_REALM}/auth.json';`,
-        "const readSecure = (file, owner, label) => { const before = fs.lstatSync(file); if (!before.isFile() || before.isSymbolicLink() || (owner !== undefined && (before.uid !== owner || before.gid !== owner)) || (before.mode & 0o777) !== 0o600 || before.nlink !== 1 || before.size < 2 || before.size > 65536) throw new Error(`unsafe broker credential ${label}`); const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK); try { const opened = fs.fstatSync(fd); if (opened.dev !== before.dev || opened.ino !== before.ino) throw new Error(`unsafe broker credential ${label}`); const bytes = Buffer.alloc(opened.size); let offset = 0; while (offset < bytes.length) { const count = fs.readSync(fd, bytes, offset, bytes.length - offset, offset); if (count < 1) throw new Error(`unsafe broker credential ${label}`); offset += count; } return bytes; } finally { fs.closeSync(fd); } };",
-        `const atomicOwned = (target, bytes) => { const temporary = \`${"${target}"}.\${process.pid}.\${crypto.randomUUID()}.tmp\`; try { const output = fs.openSync(temporary, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600); try { let written = 0; while (written < bytes.length) written += fs.writeSync(output, bytes, written, bytes.length - written, written); fs.fchmodSync(output, 0o600); fs.fchownSync(output, 2100, 2100); fs.fsyncSync(output); } finally { fs.closeSync(output); } fs.renameSync(temporary, target); const directory = fs.openSync(require('node:path').dirname(target), fs.constants.O_RDONLY | fs.constants.O_DIRECTORY); try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); } } catch (error) { try { fs.unlinkSync(temporary); } catch {} throw error; } };`,
-        "let existing; try { existing = fs.lstatSync(authority); } catch (error) { if (error.code !== 'ENOENT') throw error; } const bootstrapBytes = readSecure(bootstrap, undefined, 'bootstrap'); let bootstrapRecord; try { const root = JSON.parse(bootstrapBytes.toString('utf8')), rows = root && typeof root === 'object' && !Array.isArray(root) ? Object.entries(root).filter(([key, value]) => /^https:\\/\\/auth\\.x\\.ai::/.test(key) && value && typeof value === 'object' && !Array.isArray(value)).map(([, value]) => value) : []; if (rows.length !== 1 || typeof rows[0].key !== 'string' || !rows[0].key.trim() || typeof rows[0].refresh_token !== 'string' || !rows[0].refresh_token.trim() || typeof rows[0].expires_at !== 'string' || !Number.isFinite(Date.parse(rows[0].expires_at))) throw new Error(); bootstrapRecord = true; } catch { bootstrapBytes.fill(0); throw new Error('invalid broker credential bootstrap'); } if (!bootstrapRecord) throw new Error('invalid broker credential bootstrap'); const bootstrapDigest = crypto.createHash('sha256').update(bootstrapBytes).digest('hex');",
-        `const journalRoot = '${DAIMON_BROKER_REALM}/.daimon-broker'; let journalRootExists = false; try { const info = fs.lstatSync(journalRoot); if (!info.isDirectory() || info.isSymbolicLink() || info.uid !== 2100 || info.gid !== 2100 || (info.mode & 0o777) !== 0o700) throw new Error('unsafe broker credential journal directory'); fs.chownSync(journalRoot, 0, 0); fs.chmodSync(journalRoot, 0o700); journalRootExists = true; } catch (error) { if (error.code !== 'ENOENT') throw error; }`,
-        "const credentialExpiry = (bytes) => { try { const rows = Object.entries(JSON.parse(bytes.toString('utf8'))).filter(([key]) => /^https:\\/\\/auth\\.x\\.ai::/.test(key)).map(([, value]) => value); const expiry = rows.length === 1 && typeof rows[0]?.expires_at === 'string' ? Date.parse(rows[0].expires_at) : NaN; if (!Number.isFinite(expiry)) throw new Error(); return expiry; } catch { throw new Error('invalid broker credential expiry'); } };",
-        `try { const journalPath = '${DAIMON_BROKER_REALM}/.daimon-broker/credential-journal.json'; let journal; try { const raw = readSecure(journalPath, 2100, 'recovery journal'); journal = JSON.parse(raw.toString('utf8')); raw.fill(0); } catch (error) { if (error.code !== 'ENOENT') throw error; } const stale = journal?.version === 'noopolis.daimon.broker-credential-journal.v1' && journal.state === 'stale'; const recover = () => { if (!stale || !Number.isSafeInteger(journal.generation) || journal.generation < 0 || !/^[a-f0-9]{64}$/.test(journal.sourceDigest) || journal.sourceDigest !== journal.promotedDigest || bootstrapDigest === journal.sourceDigest) throw new Error('unsafe broker credential recovery'); atomicOwned(authority, bootstrapBytes); const recovered = Buffer.from(\`${"${JSON.stringify({ version: 'noopolis.daimon.broker-credential-journal.v1', state: 'promoted', generation: journal.generation + 1, sourceDigest: journal.sourceDigest, promotedDigest: bootstrapDigest })}"}\\n\`); try { atomicOwned(journalPath, recovered); } finally { recovered.fill(0); } }; if (!existing) { if (journal) throw new Error('broker credential authority missing; refusing bootstrap rollback'); else atomicOwned(authority, bootstrapBytes); } else { const authorityBytes = readSecure(authority, 2100, 'authority'); try { const authorityDigest = crypto.createHash('sha256').update(authorityBytes).digest('hex'); if (stale) { if (authorityDigest !== journal.sourceDigest && authorityDigest !== bootstrapDigest) throw new Error('unsafe broker credential recovery'); if (authorityDigest === bootstrapDigest && bootstrapDigest === journal.sourceDigest) throw new Error('unsafe broker credential recovery'); if (authorityDigest !== bootstrapDigest && credentialExpiry(bootstrapBytes) <= credentialExpiry(authorityBytes)) throw new Error('older broker bootstrap cannot recover newer realm'); if (authorityDigest === bootstrapDigest) { const recovered = Buffer.from(\`${"${JSON.stringify({ version: 'noopolis.daimon.broker-credential-journal.v1', state: 'promoted', generation: journal.generation + 1, sourceDigest: journal.sourceDigest, promotedDigest: bootstrapDigest })}"}\\n\`); try { atomicOwned(journalPath, recovered); } finally { recovered.fill(0); } } else recover(); } } finally { authorityBytes.fill(0); } } } finally { bootstrapBytes.fill(0); if (journalRootExists) { fs.chownSync(journalRoot, 0, 0); fs.chmodSync(journalRoot, 0o700); fs.chownSync(journalRoot, 2100, 2100); } fs.chownSync('${DAIMON_BROKER_REALM}', 0, 0); fs.chmodSync('${DAIMON_BROKER_REALM}', 0o700); fs.chownSync('${DAIMON_BROKER_REALM}', 2100, 2100); }`,
         ...renderDaimonWorkspaceResourceSecurity(workspaceResources),
-        ...renderDaimonGrokWorkerProvisioning(registrations, serviceOptions, ...(optionalDenyPaths ? [optionalDenyPaths] : [])),
+        ...renderDaimonGrokWorkerProvisioning(registrations),
         `fs.chownSync('${DAIMON_BROKER_REALM}', 0, 0); fs.chmodSync('${DAIMON_BROKER_REALM}', 0o700); fs.chownSync('${DAIMON_BROKER_REALM}', 2100, 2100);`,
         "fs.chmodSync('/etc/daimon-engine-broker', 0o555);"
     ].join("\n");
     return [
         "if [ -d /etc/daimon-engine-broker ]; then chmod u+rwx /etc/daimon-engine-broker; fi",
         "if [ -d /run/daimon-engine-broker ]; then chmod u+rwx /run/daimon-engine-broker; fi",
-        ...(rootReset === "remove"
-            ? ["rm -rf /etc/daimon-engine-broker /run/daimon-engine-broker"]
-            : [...MOUNT_AWARE_CLEAR_HELPER, "for broker_root in /etc/daimon-engine-broker /run/daimon-engine-broker; do spawnfile_clear_tree \"$broker_root\"; done"]),
+        "rm -rf /etc/daimon-engine-broker /run/daimon-engine-broker",
         `install -d -o root -g ${DAIMON_BROKER_UID} -m 0731 /run/daimon-engine-broker`,
-        `install -d -o ${DAIMON_BROKER_UID} -g ${DAIMON_BROKER_UID} -m 0700 ${brokerTmpdir}`,
-        ...beforeWorkerProvisioning,
+        `install -d -o ${DAIMON_BROKER_UID} -g ${DAIMON_BROKER_UID} -m 0700 ${DAIMON_BROKER_TMPDIR}`,
         "node <<'SPAWNFILE_DAIMON_BROKER_PROVISION'",
         program,
         "SPAWNFILE_DAIMON_BROKER_PROVISION"