spawnfile 0.1.14 → 0.1.18

package/dist/compiler/organizationIdentityGraph.js

@@ -0,0 +1,115 @@
+import { SpawnfileError } from "../shared/index.js";
+export const ORGANIZATION_ID_SEGMENT_PATTERN_SOURCE = "^[a-z][a-z0-9-]{0,62}$";
+export const ORGANIZATION_MEMBER_ID_PATTERN_SOURCE = "^[a-z][a-z0-9-]{0,62}(\\.[a-z][a-z0-9-]{0,62}){0,7}$";
+export const MAX_ORGANIZATION_MEMBER_DEPTH = 8;
+export const MAX_ORGANIZATION_MEMBER_ID_BYTES = 255;
+export const MAX_ORGANIZATION_AGENT_MEMBERS = 128;
+export const MAX_EXTERNAL_PARTICIPANTS = 32;
+const segment = new RegExp(ORGANIZATION_ID_SEGMENT_PATTERN_SOURCE, "u");
+export const organizationIdentityFail = (message) => {
+    throw new SpawnfileError("validation_error", message);
+};
+export const requiredOrganizationIdentity = (value, message) => value == null ? organizationIdentityFail(message) : value;
+export const assertOrganizationSegment = (value, label) => {
+    if (!segment.test(value)) {
+        organizationIdentityFail(`${label} must match ${ORGANIZATION_ID_SEGMENT_PATTERN_SOURCE}`);
+    }
+};
+export const freezeOrganizationIdentity = (value) => {
+    if (value && typeof value === "object") {
+        Object.freeze(value);
+        for (const child of Object.values(value)) {
+            freezeOrganizationIdentity(child);
+        }
+    }
+    return value;
+};
+export const compareOrganizationIds = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+export const exactOrganizationStrings = (actual, expected) => actual?.length === expected.length
+    && actual.every((value, index) => value === expected[index]);
+const teamNodes = (plan) => new Map(plan.nodes.filter((node) => node.kind === "team")
+    .map((node) => [node.value.source, node.value]));
+export const rootOrganizationTeam = (plan) => {
+    const node = plan.nodes.find((entry) => entry.id === plan.root || entry.value.source === plan.root);
+    return node?.value.kind === "team" ? node.value : undefined;
+};
+export const organizationAgentPaths = (plan) => {
+    const teams = teamNodes(plan);
+    const edges = plan.edges.filter((edge) => edge.kind === "team_member");
+    const paths = new Map();
+    const teamPaths = new Map();
+    const visitedNodeIds = new Set();
+    // External-participant authority needs one unambiguous path per principal.
+    // Ordinary organizations still have a canonical identity, but retain the
+    // compiler's long-standing ability to reuse an identical agent/team ref.
+    const requireUniquePaths = (rootOrganizationTeam(plan)?.externalParticipants?.length ?? 0) > 0;
+    const walk = (source, prefix, seen) => {
+        if (seen.has(source))
+            organizationIdentityFail(`organization member graph cycle at ${source}`);
+        const team = teams.get(source);
+        if (!team)
+            return;
+        if (teamPaths.has(source)) {
+            if (requireUniquePaths) {
+                organizationIdentityFail(`team is reached through multiple organization paths: ${source}`);
+            }
+            return;
+        }
+        teamPaths.set(source, prefix);
+        const node = plan.nodes.find((entry) => entry.value.source === source);
+        if (!node || node.kind !== "team") {
+            throw new SpawnfileError("validation_error", `organization graph references missing team ${source}`);
+        }
+        visitedNodeIds.add(node.id);
+        const outgoing = edges.filter((entry) => entry.from === node.id)
+            .sort((left, right) => compareOrganizationIds(left.label, right.label));
+        const memberSlots = new Set(team.members.map((member) => member.id));
+        if (memberSlots.size !== team.members.length || outgoing.length !== team.members.length) {
+            organizationIdentityFail(`organization graph cardinality mismatch for team ${team.name}`);
+        }
+        const localSlots = new Set();
+        for (const edge of outgoing) {
+            if (localSlots.has(edge.label)) {
+                organizationIdentityFail(`duplicate organization member slot: ${edge.label}`);
+            }
+            localSlots.add(edge.label);
+            assertOrganizationSegment(edge.label, "organization member slot");
+            const next = [...prefix, edge.label];
+            if (next.length > MAX_ORGANIZATION_MEMBER_DEPTH) {
+                organizationIdentityFail("organization member depth exceeds 8");
+            }
+            const child = plan.nodes.find((candidate) => candidate.id === edge.to);
+            if (!child) {
+                throw new SpawnfileError("validation_error", `organization graph references missing node ${edge.to}`);
+            }
+            const member = team.members.find((entry) => entry.id === edge.label);
+            if (!member || member.kind !== child.kind || member.nodeSource !== child.value.source) {
+                organizationIdentityFail(`organization graph member edge mismatch: ${edge.label}`);
+            }
+            if (child.kind === "agent") {
+                if (paths.has(child.value.source) && requireUniquePaths) {
+                    organizationIdentityFail(`agent source is reached through multiple organization paths: ${child.value.source}`);
+                }
+                const prior = paths.get(child.value.source);
+                if (!prior || compareOrganizationIds(next.join("."), prior.join(".")) < 0) {
+                    paths.set(child.value.source, next);
+                }
+                visitedNodeIds.add(child.id);
+            }
+            else {
+                walk(child.value.source, next, new Set([...seen, source]));
+            }
+        }
+    };
+    walk(plan.root, [], new Set());
+    const rootNode = plan.nodes.find((node) => node.value.source === plan.root);
+    const organizationNodeIds = new Set(rootNode ? [rootNode.id] : []);
+    for (const edge of edges) {
+        organizationNodeIds.add(edge.from);
+        organizationNodeIds.add(edge.to);
+    }
+    const extra = plan.nodes.find((node) => organizationNodeIds.has(node.id) && !visitedNodeIds.has(node.id));
+    if (extra)
+        organizationIdentityFail(`unreachable organization graph node: ${extra.id}`);
+    return paths;
+};

package/dist/compiler/organizationReadyEvidence.d.ts

@@ -22,6 +22,13 @@ export interface OrganizationReadinessEvidence {
             readonly nodeId: string;
         }[];
     } | null;
+    readonly daimon?: {
+        readonly receiptPath: string;
+        readonly agents: readonly {
+            readonly agentId: string;
+            readonly engine: string;
+        }[];
+    } | null;
     readonly networks: readonly {
         readonly id: string;
         readonly mode: "external" | "managed";
@@ -34,6 +41,7 @@ export interface OrganizationReadinessEvidence {
             readonly nodeId: string;
             readonly memberId: string;
             readonly configPath: string;
+            readonly receiptPath: string;
             readonly sha256: string;
         }[];
     }[];

package/dist/compiler/organizationReadyEvidence.js

@@ -96,6 +96,17 @@ const assertMemberId = (value, label) => {
     if (!MEMBER_ID.test(value))
         fail(`${label} is unbounded or noncanonical`);
 };
+const assertMoltnetRoomMemberId = (value, label) => {
+    if (MEMBER_ID.test(value))
+        return;
+    const separator = value.indexOf(":");
+    const networkId = value.slice(0, separator);
+    const agentId = value.slice(separator + 1);
+    if (separator <= 0 || separator === value.length - 1 || value.length > 128
+        || !ID.test(networkId) || !ID.test(agentId)) {
+        fail(`${label} is unbounded or noncanonical`);
+    }
+};
 const assertConfigPath = (value) => {
     if (value.length > 255 || !CONFIG_PATH.test(value)) {
         fail(`Moltnet config path is noncanonical: ${value}`);
@@ -167,14 +178,15 @@ const validateMoltnet = (artifacts, plan) => {
         const rooms = sort(server.rooms.map((room) => {
             assertId(room.id, "Moltnet room id");
             assertUnique(room.members, (member) => member, `Moltnet room member on ${server.networkId}/${room.id}`);
-            for (const member of room.members)
-                assertMemberId(member, `Moltnet room member on ${server.networkId}/${room.id}`);
+            for (const member of room.members) {
+                assertMoltnetRoomMemberId(member, `Moltnet room member on ${server.networkId}/${room.id}`);
+            }
             return { id: room.id, members: sort(room.members, (member) => member) };
         }), (room) => room.id);
         assertUnique(rooms, (room) => room.id, `Moltnet room on ${server.networkId}`);
         const nodes = sort(nodePlans.filter((node) => node.networkId === server.networkId).map((node) => {
             const attachment = attachmentByKey.get(`${node.networkId}\u0000${node.memberId}`);
-            return { configPath: node.configPath, memberId: node.memberId, nodeId: attachment.nodeId,
+            return { configPath: node.configPath, receiptPath: `/run/spawnfile/moltnet-readiness/${node.networkId}-${node.memberId}.json`, memberId: node.memberId, nodeId: attachment.nodeId,
                 sha256: sha256(emittedConfigContent(artifacts, node.configPath)) };
         }), (node) => `${node.memberId}\u0000${node.nodeId}`);
         return { id: server.networkId, internalPort: server.mode === "managed" ? server.port : null,
@@ -248,9 +260,17 @@ export const createOrganizationReadinessEvidence = (input) => {
     const projectLabel = normalizeProjectLabelSlug(distribution.organization.project);
     if (projectLabel.length > 128 || !ID.test(projectLabel))
         fail("project label is unbounded or noncanonical");
+    const daimonInstance = input.containerArtifacts.report.runtime_instances.find((instance) => instance.runtime === "daimon");
+    const daimon = daimonInstance === undefined ? null : {
+        receiptPath: "/var/lib/spawnfile/instances/daimon/daimon-organization/state/wake-acceptance/runtime-readiness.json",
+        agents: Object.entries(daimonInstance.engine_by_node_id ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([agentId, engine]) => ({ agentId, engine }))
+    };
+    if (daimon !== null && daimon.agents.length === 0)
+        fail("Daimon readiness has no compiled agent engines");
     return freeze({
         compileFingerprint: fingerprint,
         compileVersion: input.compileVersion,
+        daimon,
         hasExternalMoltnet: networks.some((network) => network.mode === "external"),
         networks,
         organizationMembers,

package/dist/compiler/preflightCompilePlan.d.ts

@@ -0,0 +1,9 @@
+import type { CompilePlan } from "./types.js";
+/**
+ * Runs, without emitting anything, the per-agent checks compile would refuse
+ * on: runtime-option errors and each adapter's `preflightAgent` (for Daimon:
+ * MCP allowlists and absolute commands, engine/model pairing, and the public
+ * instruction-size limit). Every failing agent is reported, each named by its
+ * node id, so `spawnfile validate` can be an organization's structural check.
+ */
+export declare const preflightCompilePlan: (plan: CompilePlan) => void;

package/dist/compiler/preflightCompilePlan.js

@@ -0,0 +1,38 @@
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+/**
+ * Runs, without emitting anything, the per-agent checks compile would refuse
+ * on: runtime-option errors and each adapter's `preflightAgent` (for Daimon:
+ * MCP allowlists and absolute commands, engine/model pairing, and the public
+ * instruction-size limit). Every failing agent is reported, each named by its
+ * node id, so `spawnfile validate` can be an organization's structural check.
+ */
+export const preflightCompilePlan = (plan) => {
+    const failures = new Map();
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "agent")
+            continue;
+        const runtimeName = node.runtimeName ?? node.value.runtime.name;
+        const adapter = getRuntimeAdapter(runtimeName);
+        const key = `${node.id} (${runtimeName})`;
+        const report = (message) => {
+            failures.set(key, (failures.get(key) ?? new Set()).add(message));
+        };
+        for (const diagnostic of adapter.validateRuntimeOptions?.(node.value.runtime.options) ?? []) {
+            if (diagnostic.level === "error")
+                report(diagnostic.message);
+        }
+        try {
+            adapter.preflightAgent?.(node.value, node.id);
+        }
+        catch (error) {
+            if (!(error instanceof SpawnfileError))
+                throw error;
+            report(error.message);
+        }
+    }
+    if (failures.size > 0) {
+        const lines = [...failures].flatMap(([agent, messages]) => [...messages].map((message) => `- ${agent}: ${message}`));
+        throw new SpawnfileError("validation_error", [`Compile would refuse ${failures.size} agent(s):`, ...lines].join("\n"));
+    }
+};

package/dist/compiler/recordingAgentFacts.d.ts

@@ -0,0 +1,4 @@
+import type { CompileReportWorkspaceGitResource, RecordingAgentReport } from "../report/index.js";
+import type { CompilePlan } from "./types.js";
+/** Only compiled, portable identities: no host sources and no history reads. */
+export declare const resolveRecordingAgentFacts: (plan: CompilePlan, gitPins?: readonly CompileReportWorkspaceGitResource[]) => RecordingAgentReport[];

package/dist/compiler/recordingAgentFacts.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { resolveMnemeDurableMemoryMountPath } from "../runtime/mnemeMcp.js";
+import { daimonRecordingDirectory } from "../runtime/daimon/recording.js";
+import { recordingKeepMs, SpawnfileError } from "../shared/index.js";
+import { resolveTrainingRecordVolumes } from "./training/plan/index.js";
+/** Only compiled, portable identities: no host sources and no history reads. */
+export const resolveRecordingAgentFacts = (plan, gitPins = []) => plan.nodes.flatMap((node) => {
+    if (node.value.kind !== "agent" || node.value.training?.record === undefined)
+        return [];
+    const agent = node.value;
+    const memory = new Map();
+    for (const access of agent.memoryAccess ?? []) {
+        const declaring = plan.nodes.find((entry) => entry.value.source === access.source);
+        if (!declaring)
+            throw new SpawnfileError("validation_error", `Recording bank ${access.bank.id} has no declaring node`);
+        const home = resolveMnemeDurableMemoryMountPath(access.bank);
+        memory.set(`${declaring.id}\0${access.bank.id}`, {
+            id: access.bank.id, declared_by: declaring.id,
+            ledger_path: home === null ? null : path.posix.join(home, "memory/events.jsonl")
+        });
+    }
+    const resources = agent.workspaceResources ?? [];
+    return [{
+            node_id: node.id, slug: node.slug, directory: daimonRecordingDirectory(node.slug),
+            keep_ms: recordingKeepMs(agent.training.record),
+            networks: [...new Set((agent.surfaces?.moltnet ?? []).map((entry) => entry.network))].sort(),
+            memory: [...memory.values()].sort((a, b) => `${a.declared_by}:${a.id}`.localeCompare(`${b.declared_by}:${b.id}`)),
+            feeds: resources.flatMap((resource) => resource.kind === "volume" && resource.feed
+                ? [{ id: resource.id, volume_name: resource.name }] : []).sort((a, b) => a.id.localeCompare(b.id)),
+            resources: resources.flatMap((resource) => resource.kind === "volume" ? []
+                : [{ id: resource.id, kind: gitPins.some((pin) => pin.id === resource.id && pin.agent_node_ids?.includes(node.id)) ? "git" : resource.kind }])
+                .sort((a, b) => a.id.localeCompare(b.id)),
+            snapshots: resolveTrainingRecordVolumes({ id: node.id, value: agent }).map((resource) => resource.id)
+        }];
+}).sort((a, b) => a.node_id.localeCompare(b.node_id));

package/dist/compiler/recordingCapability.d.ts

@@ -0,0 +1,4 @@
+import { type DaimonContractManifest } from "../runtime/daimon/contractManifest.js";
+import type { CompilePlan } from "./types.js";
+/** No runtime lookup, check output, or manifest I/O when recording is absent. */
+export declare const assertRecordingCapability: (plan: CompilePlan, injectedManifest?: DaimonContractManifest) => Promise<void>;

package/dist/compiler/recordingCapability.js

@@ -0,0 +1,22 @@
+import { fileURLToPath } from "node:url";
+import { DAIMON_CONTRACT_MANIFEST_SHA256, daimonSupportsWakeMoments, readVerifiedDaimonContractManifest } from "../runtime/daimon/contractManifest.js";
+import { SpawnfileError } from "../shared/index.js";
+/** No runtime lookup, check output, or manifest I/O when recording is absent. */
+export const assertRecordingCapability = async (plan, injectedManifest) => {
+    const agents = plan.nodes.filter((node) => node.kind === "agent" && node.value.training?.record !== undefined);
+    if (agents.length === 0)
+        return;
+    for (const agent of agents) {
+        if (agent.runtimeName !== "daimon")
+            throw new SpawnfileError("validation_error", `Training recording for ${agent.id} requires Daimon; runtime ${agent.runtimeName ?? "unknown"} does not support wake moments`);
+    }
+    let manifest = injectedManifest;
+    if (manifest === undefined) {
+        const verified = await readVerifiedDaimonContractManifest(fileURLToPath(new URL("../runtime/daimon/", import.meta.url)));
+        if (verified.digest !== DAIMON_CONTRACT_MANIFEST_SHA256)
+            throw new SpawnfileError("validation_error", "Pinned Daimon contract manifest does not match the capability-receipt digest");
+        manifest = verified.manifest;
+    }
+    if (!daimonSupportsWakeMoments(manifest))
+        throw new SpawnfileError("validation_error", "The pinned Daimon runtime image does not declare the wakeMoments capability; a Daimon release with it and a runtimes.yaml / contract-manifest re-pin are required");
+};

package/dist/compiler/recordingReport.d.ts

@@ -0,0 +1,4 @@
+import type { CompileReport, ContainerMemoryReport, RecordingReport } from "../report/index.js";
+import type { CompilePlan } from "./types.js";
+/** Project effective agent declarations and existing memory access facts only. */
+export declare const resolveRecordingReport: (plan: CompilePlan, memories: readonly ContainerMemoryReport[], gitPins?: CompileReport["workspace_git_resources"]) => RecordingReport | undefined;

package/dist/compiler/recordingReport.js

@@ -0,0 +1,18 @@
+import { maxRecordingKeepMs } from "../shared/index.js";
+import { daimonRecordingMountId } from "../runtime/daimon/recording.js";
+import { resolveRecordingAgentFacts } from "./recordingAgentFacts.js";
+/** Project effective agent declarations and existing memory access facts only. */
+export const resolveRecordingReport = (plan, memories, gitPins = []) => {
+    const agents = plan.nodes.filter((node) => node.kind === "agent" && node.value.training?.record !== undefined);
+    const keepMs = maxRecordingKeepMs(agents.map((node) => node.value.training?.record));
+    if (keepMs === undefined)
+        return undefined;
+    const agentIds = new Set(agents.map((node) => node.id));
+    const memoryMountIds = memories.flatMap((memory) => memory.store.persistent_mount_id !== undefined && memory.accessible_node_ids.some((id) => agentIds.has(id))
+        ? [memory.store.persistent_mount_id] : []);
+    return {
+        keep_ms: keepMs, memory_mount_ids: [...new Set(memoryMountIds)].sort(),
+        recording_mount_ids: agents.filter((agent) => agent.runtimeName === "daimon").map((agent) => daimonRecordingMountId(agent.slug)).sort(),
+        agents: resolveRecordingAgentFacts(plan, gitPins)
+    };
+};

package/dist/compiler/runProject.d.ts

@@ -1,8 +1,8 @@
 import { type ResolvedAuthProfile } from "../auth/index.js";
-import { type DockerTargetExecFile } from "../deployment/index.js";
+import { type DeploymentRecord, type DockerTargetExecFile } from "../deployment/index.js";
 import { type CompileProjectOptions, type CompileProjectResult } from "./compileProject.js";
-import { runDockerContainer, type DockerRunInvocation, type DockerRunResult, type DockerRunRunner } from "./runProjectDocker.js";
-export { runDockerContainer };
+import { inspectDetachedContainer as recoverDetachedDockerRun, runDockerContainer, type DockerRunInvocation, type DockerRunResult, type DockerRunRunner } from "./runProjectDocker.js";
+export { recoverDetachedDockerRun, runDockerContainer };
 export type { DockerRunInvocation, DockerRunResult, DockerRunRunner };
 export interface RunProjectOptions extends CompileProjectOptions {
     authProfile?: string;
@@ -29,6 +29,8 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
         name: string;
         value: string;
     };
+    /** See `RuntimeAuthPreparationInput.containerCredentialUid`. */
+    containerCredentialUid?: number;
     containerName?: string;
     detach?: boolean;
     deploymentName?: string;
@@ -38,6 +40,7 @@ export declare const createDockerRunInvocation: (compileResult: CompileProjectRe
     envFilePath?: string;
 }) => Promise<DockerRunInvocation>;
 interface ResolvedRunDeploymentOptions {
+    previousRecord?: DeploymentRecord;
     authProfile?: string;
     containerName?: string;
     deploymentName?: string;

package/dist/compiler/runProject.js

@@ -4,15 +4,16 @@ import { mkdtemp } from "node:fs/promises";
 import { requireAuthProfile } from "../auth/index.js";
 import { ensureDirectory, fileExists, removeDirectory, writeUtf8File } from "../filesystem/index.js";
 import { appendDockerLabelArgs, createDockerDeploymentLabels, createDockerDeploymentUnitId, createDockerProjectLabel, dockerContextNameForTarget, dockerHostValueForTarget, normalizeDeploymentName, readDeploymentRecordFromOutput, resolveDeploymentRecordPath, verifyDockerDeploymentTarget, writeDockerDeploymentRecordForRun } from "../deployment/index.js";
-import { DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
+import { DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
 import { ensureNoopolisRunId, resolveNoopolisRunId } from "../runtime/index.js";
 import { compileProject } from "./compileProject.js";
 import { createDefaultImageTag, resolveDockerBuildArchitecture } from "./buildProject.js";
 import { slugify } from "./helpers.js";
-import { runDockerContainer } from "./runProjectDocker.js";
+import { resolveDaimonCodexNativeSandboxDockerSecurityOptions } from "./runProjectDaimonCodexDocker.js";
+import { inspectDetachedContainer as recoverDetachedDockerRun, runDockerContainer } from "./runProjectDocker.js";
 import { executeDockerRunWithSupportCleanup } from "./runProjectLifecycle.js";
 import { assertDeclaredModelAuthSatisfied, assertMoltnetCredentialValuesDistinct, assertRunEnvironmentSatisfied, prepareRuntimeAuthMounts, readRunEnvFile, renderDockerEnvFile, resolveAuthMountArgs, resolveRunEnvironment } from "./runProjectAuth.js";
-export { runDockerContainer };
+export { recoverDetachedDockerRun, runDockerContainer };
 const resolveImageTagRoot = (inputPath) => {
     const resolvedPath = path.resolve(inputPath);
     return path.basename(resolvedPath).toLowerCase() === "spawnfile"
@@ -36,9 +37,11 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             ...(await readRunEnvFile(options.envFilePath)),
             ...(options.cliCredential ? { [options.cliCredential.name]: options.cliCredential.value } : {})
         });
-        const preparedRuntimeAuth = await prepareRuntimeAuthMounts(compileResult.outputDirectory, containerReport, options.authProfile ?? null, env, supportDirectory);
+        const preparedRuntimeAuth = await prepareRuntimeAuthMounts(compileResult.outputDirectory, containerReport, options.authProfile ?? null, env, supportDirectory, options.containerCredentialUid);
         assertRunEnvironmentSatisfied(containerReport, env, preparedRuntimeAuth.coveredModelSecrets);
         assertMoltnetCredentialValuesDistinct(containerReport, env);
+        const hasDaimon = containerReport.runtime_instances.some((instance) => instance.runtime === "daimon");
+        const opaqueDaimonCredentials = preparedRuntimeAuth.launchIdentity?.kind === "daimon";
         await ensureDirectory(supportDirectory);
         await writeUtf8File(envFilePath, renderDockerEnvFile(env));
         const deploymentName = options.deploymentName
@@ -53,17 +56,32 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
                 ? ["--host", options.dockerHost, "run"]
                 : ["run"];
         if (options.detach) {
-            args.push("-d");
+            args.push("-d", "--restart", "unless-stopped");
         }
         else {
             args.push("--rm");
         }
         args.push("--name", containerName);
+        if (hasDaimon) {
+            args.push(...DAIMON_DOCKER_RUNTIME_SECURITY_ARGS, ...(await resolveDaimonCodexNativeSandboxDockerSecurityOptions(compileResult)));
+        }
         for (const port of containerReport.ports) {
             args.push("-p", `${port}:${port}`);
         }
+        // Compiler-owned persistent mounts are mounted WITHOUT `volume-nocopy`.
+        // The image is the authority for the bootstrap preimage at these paths:
+        // `createStateOwnershipCommand` writes a `.spawnfile-volume-init` marker
+        // into every one of them at build time, and the Daimon ownership guard
+        // (`secureVolumeIdentity`) and `prepare_volume_resource` both REQUIRE that
+        // marker as the fresh-volume preimage. `volume-nocopy` is exactly the flag
+        // that stops Docker copying image content into an empty volume, so it
+        // starved the guard and no Daimon organization with persistent volumes
+        // could bootstrap. Copy-up only ever populates an EMPTY volume, so a
+        // 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.)
         for (const mount of containerReport.persistent_mounts ?? []) {
-            args.push("-v", `${mount.volume_name}:${mount.mount_path}`);
+            args.push("--mount", `type=volume,source=${mount.volume_name},target=${mount.mount_path}`);
         }
         const deploymentLabels = options.detach && deploymentName ? (() => {
             const compileFingerprint = compileResult.report.compile_fingerprint ?? "sf1:unknown";
@@ -91,7 +109,14 @@ export const createDockerRunInvocation = async (compileResult, imageTag, options
             dockerContext: options.dockerContext ?? null,
             dockerHost: options.dockerHost ?? null,
             envFilePath,
+            ...((containerReport.persistent_mounts ?? []).some((mount) => mount.lifecycle === "exclusive-reattach") ? {
+                exclusiveReattachVolumes: (containerReport.persistent_mounts ?? [])
+                    .filter((mount) => mount.lifecycle === "exclusive-reattach")
+                    .map((mount) => mount.volume_name)
+                    .sort()
+            } : {}),
             imageTag,
+            ...(opaqueDaimonCredentials ? { opaqueDaimonCredentials } : {}),
             supportDirectory
         };
     }
@@ -128,6 +153,7 @@ export const resolveDetachedDeploymentOptions = async (outputDirectory, options)
         });
     }
     return {
+        previousRecord: record,
         authProfile: options.authProfile ?? record.auth_profile ?? undefined,
         containerName: options.containerName ?? unit?.container_name ?? undefined,
         deploymentName,
@@ -164,6 +190,7 @@ export const runProject = async (inputPath, options = {}) => {
     const compileResult = await compileProject(inputPath, {
         clean: options.clean,
         containerArchitecture: targetArchitecture,
+        deploymentLineage: resolvedOptions.deploymentName ?? "ephemeral",
         outputDirectory: options.outputDirectory,
         ...(options.worldBindingsPath !== undefined
             ? { worldBindingsPath: options.worldBindingsPath }
@@ -186,6 +213,7 @@ export const runProject = async (inputPath, options = {}) => {
     const runMetadata = await executeDockerRunWithSupportCleanup(invocation, options.runRunner ?? runDockerContainer);
     const deploymentRecordPath = invocation.detach && invocation.deploymentName
         ? await writeDockerDeploymentRecordForRun({
+            previousRecord: resolvedOptions.previousRecord,
             authProfileName: authProfile?.name ?? null,
             envFilePath: resolvedOptions.envFilePath,
             imageTag,

package/dist/compiler/runProjectAuth.d.ts

@@ -1,7 +1,9 @@
 import type { ResolvedAuthProfile } from "../auth/index.js";
 import type { ContainerReport } from "../report/index.js";
+import type { RuntimeAuthPreparationResult } from "../runtime/types.js";
 interface PreparedRunAuth {
     coveredModelSecrets: Set<string>;
+    launchIdentity?: RuntimeAuthPreparationResult["launchIdentity"];
     mountArgs: string[];
 }
 export declare const resolveHostCliCredential: (containerReport: ContainerReport) => Promise<{
@@ -9,7 +11,7 @@ export declare const resolveHostCliCredential: (containerReport: ContainerReport
     sourcePath: string;
     value: string;
 } | null>;
-export declare const prepareRuntimeAuthMounts: (outputDirectory: string, containerReport: ContainerReport, authProfile: ResolvedAuthProfile | null, env: Record<string, string>, tempRoot: string) => Promise<PreparedRunAuth>;
+export declare const prepareRuntimeAuthMounts: (outputDirectory: string, containerReport: ContainerReport, authProfile: ResolvedAuthProfile | null, env: Record<string, string>, tempRoot: string, containerCredentialUid?: number) => Promise<PreparedRunAuth>;
 export declare const assertDeclaredModelAuthSatisfied: (containerReport: ContainerReport, authProfile: ResolvedAuthProfile | null, cliCredentialProvided?: boolean) => void;
 export declare const resolveRunEnvironment: (containerReport: ContainerReport, authProfile: ResolvedAuthProfile | null, envFileEnv?: Record<string, string>) => Record<string, string>;
 export declare const assertRunEnvironmentSatisfied: (containerReport: ContainerReport, env: Record<string, string>, coveredModelSecrets: Set<string>) => void;

package/dist/compiler/runProjectAuth.js

@@ -10,6 +10,7 @@ const MODEL_AUTH_IMPORT_KINDS = {
     api_key: null,
     "claude-code": "claude-code",
     codex: "codex",
+    grok: null,
     none: null
 };
 export const resolveHostCliCredential = async (containerReport) => {
@@ -44,7 +45,7 @@ const addCoveredModelSecrets = (coveredModelSecrets, instanceId, secretNames) =>
         coveredModelSecrets.add(`${instanceId}:${secretName}`);
     }
 };
-export const prepareRuntimeAuthMounts = async (outputDirectory, containerReport, authProfile, env, tempRoot) => {
+export const prepareRuntimeAuthMounts = async (outputDirectory, containerReport, authProfile, env, tempRoot, containerCredentialUid) => {
     // No early return when `authProfile` is null: an adapter's
     // `prepareRuntimeAuth` may still have host-credential staging to do that
     // does not depend on an imported Spawnfile auth profile (e.g. the Pi
@@ -53,6 +54,7 @@ export const prepareRuntimeAuthMounts = async (outputDirectory, containerReport,
     // responsible for treating a `null` `authProfile` as "no profile-derived
     // imports available" rather than failing.
     const coveredModelSecrets = new Set();
+    let launchIdentity;
     const mountArgs = [];
     for (const instance of containerReport.runtime_instances) {
         const adapter = getRuntimeAdapter(instance.runtime);
@@ -61,15 +63,26 @@ export const prepareRuntimeAuthMounts = async (outputDirectory, containerReport,
         }
         const prepared = await adapter.prepareRuntimeAuth({
             authProfile,
+            ...(containerCredentialUid === undefined ? {} : { containerCredentialUid }),
             env,
             instance,
             outputDirectory,
             tempRoot
         });
         addCoveredModelSecrets(coveredModelSecrets, instance.id, prepared.coveredModelSecrets);
+        if (prepared.launchIdentity) {
+            if (launchIdentity && launchIdentity.uid !== prepared.launchIdentity.uid) {
+                throw new SpawnfileError("validation_error", "Opaque runtime credentials resolve conflicting launch UIDs");
+            }
+            launchIdentity = prepared.launchIdentity;
+        }
         mountArgs.push(...prepared.mountArgs);
     }
-    return { coveredModelSecrets, mountArgs };
+    return {
+        coveredModelSecrets,
+        ...(launchIdentity ? { launchIdentity } : {}),
+        mountArgs
+    };
 };
 export const assertDeclaredModelAuthSatisfied = (containerReport, authProfile, cliCredentialProvided = false) => {
     const requiredImportKinds = new Set();
@@ -108,6 +121,9 @@ const createGeneratedRuntimeSecret = (secretName, generatedMoltnetSecrets) => {
     if (generatedMoltnetSecrets.has(secretName)) {
         return randomBytes(32).toString("base64url");
     }
+    if (secretName === "SPAWNFILE_DAIMON_CONTROL_TOKEN") {
+        return randomBytes(32).toString("base64url");
+    }
     return null;
 };
 const hasEnvValue = (env, name) => typeof env[name] === "string" && env[name].length > 0;
@@ -215,7 +231,7 @@ export const resolveAuthMountArgs = async (containerReport, authProfile) => {
     // Mounting the generic imported home onto the same destination would create
     // duplicate Docker mount points and bypass the adapter's minimal-file staging.
     const piRuntimeHomes = new Set(containerReport.runtime_instances
-        .filter((instance) => instance.runtime === "pi" || instance.runtime === "daimon")
+        .filter((instance) => instance.runtime === "pi")
         .map((instance) => instance.home_path)
         .filter((homePath) => homePath !== null));
     const genericRuntimeHomes = containerReport.runtime_homes

package/dist/compiler/runProjectDaimonCodexDocker.d.ts

@@ -0,0 +1,3 @@
+import type { CompileProjectResult } from "./compileProject.js";
+export { DAIMON_CODEX_NATIVE_SANDBOX_DOCKER_SECURITY_OPTS } from "../shared/index.js";
+export declare const resolveDaimonCodexNativeSandboxDockerSecurityOptions: (compileResult: CompileProjectResult) => Promise<string[]>;

package/dist/compiler/runProjectDaimonCodexDocker.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { readUtf8File } from "../filesystem/index.js";
+import { daimonEngineDockerSecurityArgsForConfigs, materializeDaimonGrokSeccompProfile, SpawnfileError } from "../shared/index.js";
+export { DAIMON_CODEX_NATIVE_SANDBOX_DOCKER_SECURITY_OPTS } from "../shared/index.js";
+const assertContainedPath = (root, candidate) => {
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
+    const relative = path.relative(normalizedRoot, normalizedCandidate);
+    if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new SpawnfileError("validation_error", "Daimon generated config path escapes the compiled container rootfs");
+    }
+    return normalizedCandidate;
+};
+const configPathInOutput = (outputDirectory, instance) => {
+    if (!instance.config_path.startsWith("/")) {
+        throw new SpawnfileError("validation_error", "Daimon runtime instance has a non-absolute generated config path");
+    }
+    const rootfs = path.join(outputDirectory, "container", "rootfs");
+    return assertContainedPath(rootfs, path.join(rootfs, `.${instance.config_path}`));
+};
+export const resolveDaimonCodexNativeSandboxDockerSecurityOptions = async (compileResult) => {
+    const instances = compileResult.report.container?.runtime_instances
+        .filter((instance) => instance.runtime === "daimon") ?? [];
+    const sources = [];
+    for (const instance of instances) {
+        try {
+            sources.push(await readUtf8File(configPathInOutput(compileResult.outputDirectory, instance)));
+        }
+        catch (error) {
+            if (error instanceof SpawnfileError)
+                throw error;
+            throw new SpawnfileError("validation_error", "Could not read Daimon's generated organization config before Docker launch");
+        }
+    }
+    return daimonEngineDockerSecurityArgsForConfigs(sources, () => materializeDaimonGrokSeccompProfile(path.join(compileResult.outputDirectory, "container", "security")));
+};

package/dist/compiler/runProjectDocker.d.ts

@@ -9,18 +9,22 @@ export interface DockerRunInvocation {
     dockerContext?: string | null;
     dockerHost?: string | null;
     envFilePath: string;
+    /** Host-stable credential realms that must have at most one live deployment. */
+    exclusiveReattachVolumes?: readonly string[];
     imageTag: string;
-    onDetachedStarted?: (result: {
-        containerId: string;
-    }) => Promise<void>;
+    onDetachedStarted?: (result: DockerRunResult) => Promise<void>;
+    /** Ephemeral guard; never serialized into reports, records, or labels. */
+    opaqueDaimonCredentials?: boolean;
     supportDirectory: string;
 }
 export interface DockerRunResult {
     containerId?: string;
+    containerName?: string;
     deploymentLabels?: Readonly<Record<string, string>>;
     imageId?: string;
 }
 export type DockerRunRunner = (invocation: DockerRunInvocation) => Promise<DockerRunResult | void>;
 export declare const createDetachedContainerInspectArgs: (invocation: DockerRunInvocation, containerId: string) => string[];
-export declare const parseDetachedContainerInspect: (stdout: string, expectedContainerId: string, expectedLabels?: Readonly<Record<string, string>>) => DockerRunResult;
+export declare const parseDetachedContainerInspect: (stdout: string, expectedContainerId: string, expectedLabels?: Readonly<Record<string, string>>, expectedContainerName?: string | null) => DockerRunResult;
+export declare const inspectDetachedContainer: (invocation: DockerRunInvocation, containerId: string) => Promise<DockerRunResult>;
 export declare const runDockerContainer: DockerRunRunner;