spawnfile 0.1.13 → 0.1.17

package/dist/compiler/moltnetArtifacts.js

@@ -1,113 +1,55 @@
-import { SpawnfileError } from "../shared/index.js";
-import { createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, createMoltnetServerConfigPath, resolveMoltnetClientAuth, resolveMoltnetBaseUrl, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
+import { resolveNoopolisRunId } from "../runtime/index.js";
+import { createExclusiveReattachVolumeName, SpawnfileError } from "../shared/index.js";
+import { createMoltnetCausalDirectory, createMoltnetDaimonReceiptStorePath, createMoltnetNetworkStateDirectory, createMoltnetServerConfigPath, createMoltnetOpenTokenDirectory, createMoltnetNativeServerConfig, createMoltnetNodeConfigPath, resolveMoltnetClientAuth, resolveMoltnetStorePersistenceMountPath } from "./moltnetConfigLowering.js";
 import { assertNetworkBindingEnvUniqueness } from "./networkBinding.js";
-import { listConcreteMoltnetRoomMemberIds } from "./moltnetRoomMemberships.js";
-import { assertCompatibleMoltnetNetworkName, assertCompatibleMoltnetRoomPolicy, assertCompatibleMoltnetServer } from "./moltnetRoomPolicyCompatibility.js";
 import { createMoltnetNodeConfigContent } from "./moltnetNodeConfig.js";
-import { createShortHash, slugify } from "./helpers.js";
-const DEFAULT_MOLTNET_PORT = 8787;
-const ROOTFS_PREFIX = "container/rootfs";
+import { createPersistentVolumeName, isNetworkHttpEnabled, toContainerRootfsPath } from "./moltnetArtifactPaths.js";
+import { createMoltnetExternalParticipantArtifactFiles } from "./moltnetExternalParticipantArtifact.js";
+import { resolveMoltnetServerPlans } from "./moltnetServerPlans.js";
 const createServerKey = (networkId) => networkId;
-const truncateSegment = (value, maxLength) => value.length > maxLength ? value.slice(0, maxLength).replace(/[-_.]+$/u, "") : value;
-const createPersistentVolumeName = (planRoot, id, explicitName) => {
-    if (explicitName && explicitName.trim().length > 0) {
-        return explicitName.trim();
-    }
-    const project = truncateSegment(slugify(planRoot.split("/").slice(-2, -1)[0] ?? "project") || "project", 32);
-    const suffix = truncateSegment(slugify(id) || "state", 48);
-    return `spawnfile-${project}-${suffix}-${createShortHash(`${planRoot}:${id}`)}`;
-};
-const toContainerRootfsPath = (rootfsPath) => `/${rootfsPath.replace(`${ROOTFS_PREFIX}/`, "")}`;
-const isNetworkHttpEnabled = (network) => network.server?.mode === "managed" && network.server.human_ingress === true;
-const resolveNetworkPort = (network, fallbackPort) => network.server?.mode === "managed" ? network.server.listen.port : fallbackPort;
-export const generateMoltnetArtifacts = async (plan) => {
+export const generateMoltnetArtifacts = async (plan, deploymentLineage = "compile") => {
     const teamNodes = plan.nodes
         .filter((node) => node.kind === "team")
         .filter((node) => (node.value.networks?.length ?? 0) > 0);
     if (teamNodes.length === 0) {
         return null;
     }
-    const serverPlans = new Map();
-    let nextPort = DEFAULT_MOLTNET_PORT;
-    for (const teamNode of teamNodes) {
-        for (const network of teamNode.value.networks ?? []) {
-            const server = network.server;
-            if (!server) {
-                throw new SpawnfileError("validation_error", `Moltnet network ${network.id} must declare server`);
-            }
-            const serverKey = createServerKey(network.id);
-            const existingPlan = serverPlans.get(serverKey);
-            if (existingPlan) {
-                if (existingPlan.baseUrl !== resolveMoltnetBaseUrl(server)) {
-                    throw new SpawnfileError("validation_error", `Duplicate Moltnet network ${network.id} declares conflicting server URL`);
-                }
-                assertCompatibleMoltnetNetworkName(network.id, existingPlan.name, network.name);
-                assertCompatibleMoltnetServer(network.id, existingPlan.server, server);
-                for (const room of network.rooms) {
-                    const concreteMembers = listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room);
-                    const existingRoom = existingPlan.rooms.find((entry) => entry.id === room.id);
-                    if (existingRoom) {
-                        existingRoom.members = [
-                            ...new Set([...existingRoom.members, ...concreteMembers])
-                        ].sort();
-                        assertCompatibleMoltnetRoomPolicy(network.id, room.id, "visibility", existingRoom.visibility, room.visibility);
-                        assertCompatibleMoltnetRoomPolicy(network.id, room.id, "write_policy", existingRoom.write_policy, room.write_policy);
-                        existingRoom.visibility ??= room.visibility;
-                        existingRoom.write_policy ??= room.write_policy;
-                    }
-                    else {
-                        existingPlan.rooms.push({
-                            id: room.id,
-                            members: concreteMembers,
-                            ...(room.name ? { name: room.name } : {}),
-                            ...(room.visibility ? { visibility: room.visibility } : {}),
-                            ...(room.write_policy ? { write_policy: room.write_policy } : {})
-                        });
-                    }
-                }
-                existingPlan.rooms.sort((left, right) => left.id.localeCompare(right.id));
-            }
-            else {
-                const port = server.mode === "managed" ? resolveNetworkPort(network, nextPort) : undefined;
-                const serverId = `${teamNode.slug}-${network.id}`;
-                serverPlans.set(serverKey, {
-                    baseUrl: resolveMoltnetBaseUrl(server),
-                    ...(server.mode === "managed"
-                        ? { configPath: toContainerRootfsPath(createMoltnetServerConfigPath(serverId)) }
-                        : {}),
-                    id: serverId,
-                    mode: server.mode,
-                    name: network.name,
-                    networkId: network.id,
-                    ...(port ? { port } : {}),
-                    rooms: network.rooms.map((room) => ({
-                        id: room.id,
-                        members: listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room),
-                        ...(room.name ? { name: room.name } : {}),
-                        ...(room.visibility ? { visibility: room.visibility } : {}),
-                        ...(room.write_policy ? { write_policy: room.write_policy } : {})
-                    })),
-                    server,
-                    secretPatches: [],
-                    teamSource: teamNode.value.source
-                });
-                if (port) {
-                    nextPort = Math.max(nextPort, port + 1);
-                }
-            }
-        }
-    }
+    // Run-scoping key for the RUN-SCOPED mounts derived below — the causal
+    // event log and per-network Moltnet runtime state (see
+    // createPersistentVolumeName's doc comment). Read once per compile so every
+    // such mount in this compile agrees on the same value. Durable stores and
+    // token directories deliberately do NOT use it; see durableVolumeName.
+    const runId = resolveNoopolisRunId(process.env);
+    /**
+     * Deployment-stable name for state that must be REATTACHED across a
+     * redeploy, never recreated empty: durable Moltnet `sqlite`/`json` stores
+     * and the open-mode agent token directories. An author-declared name
+     * (`server.store.persistence.name`) is honoured verbatim so an operator can
+     * pre-create or migrate the volume under that exact name; otherwise the
+     * name comes from the plan root plus the deployment lineage, exactly as
+     * durable memory banks are named (`memoryArtifacts.ts`'s
+     * `durableMemoryVolumeName`).
+     */
+    const durableVolumeName = (mountId, declaredName) => declaredName?.trim()
+        || createExclusiveReattachVolumeName(`${plan.root}\0${deploymentLineage}`, mountId);
+    const serverPlans = resolveMoltnetServerPlans(plan, teamNodes);
     const nodePlans = [];
     const nodePlanKeys = new Set();
     const configFiles = [];
     const persistentMounts = new Map();
+    const external = createMoltnetExternalParticipantArtifactFiles(plan.moltnetExternalParticipantIntents ?? []);
+    const receiptStoreOwners = new Map();
+    configFiles.push(...external.files);
     const addPersistentMount = (mount) => {
         const existing = persistentMounts.get(mount.id);
         if (!existing) {
             persistentMounts.set(mount.id, mount);
             return;
         }
-        if (existing.mountPath !== mount.mountPath || existing.volumeName !== mount.volumeName) {
+        if (existing.mountPath !== mount.mountPath ||
+            existing.volumeName !== mount.volumeName ||
+            existing.lifecycle !== mount.lifecycle ||
+            existing.declaredVolumeName !== mount.declaredVolumeName) {
             throw new SpawnfileError("validation_error", `Moltnet persistent mount ${mount.id} resolves to conflicting targets`);
         }
     };
@@ -127,18 +69,34 @@ export const generateMoltnetArtifacts = async (plan) => {
             mode: 0o600,
             path: createMoltnetServerConfigPath(serverPlan.id)
         });
+        // Always mounted, independent of the network's store.kind/persistence:
+        // this is the causal/social record (message.accepted/message.denied
+        // events), the A5/memetics ground truth for what happened in a run, and
+        // it must survive container teardown even for a purely in-memory
+        // (non-durable) room store — e.g. office-sim's fixture. Lives in its own
+        // `causal/` subdirectory, never the server config's own directory, so
+        // this volume never shadows a rebuilt image's Moltnet.json.
+        const causalMountId = `moltnet-${serverPlan.networkId}-causal`;
+        addPersistentMount({
+            id: causalMountId,
+            mountPath: createMoltnetCausalDirectory(serverPlan.configPath),
+            reason: `managed Moltnet causal event log for ${serverPlan.networkId}`,
+            volumeName: createPersistentVolumeName(plan.root, causalMountId, runId)
+        });
         const storeMountPath = resolveMoltnetStorePersistenceMountPath(serverPlan.networkId, serverPlan.server.store);
         if (storeMountPath) {
             const mountId = `moltnet-${serverPlan.networkId}-store`;
             const store = serverPlan.server.store;
-            const volumeName = store.kind === "sqlite" || store.kind === "json"
+            const explicitVolumeName = store.kind === "sqlite" || store.kind === "json"
                 ? store.persistence?.name
                 : undefined;
             addPersistentMount({
+                ...(explicitVolumeName?.trim() ? { declaredVolumeName: explicitVolumeName.trim() } : {}),
                 id: mountId,
+                lifecycle: "exclusive-reattach",
                 mountPath: storeMountPath,
                 reason: `managed Moltnet ${serverPlan.server.store.kind} store for ${serverPlan.networkId}`,
-                volumeName: createPersistentVolumeName(plan.root, mountId, volumeName)
+                volumeName: durableVolumeName(mountId, explicitVolumeName)
             });
         }
     }
@@ -166,20 +124,36 @@ export const generateMoltnetArtifacts = async (plan) => {
             if (!network) {
                 throw new SpawnfileError("validation_error", `Unable to find Moltnet network ${attachment.network} for ${agentNode.name}`);
             }
-            if (network.server?.mode === "managed" && network.server.direct_messages === false && attachment.dms) {
+            if (serverPlan.server.mode === "managed" &&
+                serverPlan.server.direct_messages === false &&
+                attachment.dms) {
                 throw new SpawnfileError("validation_error", `Moltnet network ${attachment.network} disables direct messages but ${agentNode.name} declares dms`);
             }
-            if (!network.server) {
-                throw new SpawnfileError("validation_error", `Moltnet network ${attachment.network} must declare server`);
-            }
             const configPath = createMoltnetNodeConfigPath(teamNode.slug, attachment.network, attachment.memberId);
+            const receiptStorePath = agentNode.runtime.name === "daimon"
+                ? createMoltnetDaimonReceiptStorePath(attachment.network, attachment.memberId)
+                : undefined;
+            if (receiptStorePath) {
+                const owner = `${attachment.network}\u0000${attachment.memberId}`;
+                const existingOwner = receiptStoreOwners.get(receiptStorePath);
+                if (existingOwner !== undefined && existingOwner !== owner) {
+                    throw new SpawnfileError("validation_error", "Daimon receipt-store paths collide");
+                }
+                receiptStoreOwners.set(receiptStorePath, owner);
+                const networkRoot = createMoltnetNetworkStateDirectory(attachment.network);
+                const covered = [...persistentMounts.values()].some((mount) => networkRoot === mount.mountPath || networkRoot.startsWith(`${mount.mountPath}/`));
+                if (!covered) {
+                    const mountId = `moltnet-${attachment.network}-runtime-state`;
+                    addPersistentMount({ id: mountId, mountPath: networkRoot, reason: `Moltnet runtime state for ${attachment.network}`, volumeName: createPersistentVolumeName(plan.root, mountId, runId) });
+                }
+            }
             const nodePlanKey = `${attachment.network}::${attachment.memberId}`;
             if (nodePlanKeys.has(nodePlanKey)) {
                 throw new SpawnfileError("validation_error", `Duplicate Moltnet node attachment for ${attachment.network}/${attachment.memberId}`);
             }
             nodePlanKeys.add(nodePlanKey);
             if (agentNode.runtime.name === "pi") {
-                const clientAuth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, node.slug);
+                const clientAuth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, node.slug, attachment.auth?.tokenId);
                 const usesPerAttachmentOpenToken = clientAuth.mode === "open" &&
                     clientAuth.staticToken !== true &&
                     Boolean(clientAuth.tokenEnv || clientAuth.tokenPath);
@@ -187,9 +161,10 @@ export const generateMoltnetArtifacts = async (plan) => {
                     const mountId = `agent-${node.slug}-moltnet-tokens`;
                     addPersistentMount({
                         id: mountId,
+                        lifecycle: "exclusive-reattach",
                         mountPath: createMoltnetOpenTokenDirectory(node.slug),
                         reason: `Moltnet open-mode generated agent tokens for ${agentNode.name}`,
-                        volumeName: createPersistentVolumeName(plan.root, mountId)
+                        volumeName: durableVolumeName(mountId)
                     });
                 }
             }
@@ -206,9 +181,10 @@ export const generateMoltnetArtifacts = async (plan) => {
                 const mountId = `agent-${node.slug}-moltnet-tokens`;
                 addPersistentMount({
                     id: mountId,
+                    lifecycle: "exclusive-reattach",
                     mountPath: createMoltnetOpenTokenDirectory(node.slug),
                     reason: `Moltnet open-mode generated agent tokens for ${agentNode.name}`,
-                    volumeName: createPersistentVolumeName(plan.root, mountId)
+                    volumeName: durableVolumeName(mountId)
                 });
             }
             configFiles.push({
@@ -218,7 +194,14 @@ export const generateMoltnetArtifacts = async (plan) => {
             });
             nodePlans.push({
                 configPath: toContainerRootfsPath(configPath),
-                networkId: attachment.network
+                ...(clientAuth.credentialAgentId
+                    ? { credentialAgentId: clientAuth.credentialAgentId }
+                    : {}),
+                ...(clientAuth.credentialId ? { credentialId: clientAuth.credentialId } : {}),
+                ...(clientAuth.tokenEnv ? { credentialSecret: clientAuth.tokenEnv } : {}),
+                memberId: attachment.memberId,
+                networkId: attachment.network,
+                ...(receiptStorePath ? { receiptStorePath } : {})
             });
         }
     }
@@ -229,6 +212,9 @@ export const generateMoltnetArtifacts = async (plan) => {
     })));
     return {
         files: configFiles,
+        ...(external.artifacts.length > 0
+            ? { externalParticipantArtifacts: external.artifacts }
+            : {}),
         nodePlans: nodePlans.sort((left, right) => left.configPath.localeCompare(right.configPath)),
         persistentMounts: [...persistentMounts.values()].sort((left, right) => left.id.localeCompare(right.id)),
         ports: [...new Set(managedServerPlans.map((serverPlan) => serverPlan.port).filter((port) => port !== undefined))].sort((left, right) => left - right),

package/dist/compiler/moltnetBinaries.d.ts

@@ -1,7 +1,36 @@
+import { type MoltnetBridgeCapabilities, type MoltnetTargetArchitecture } from "./moltnetReleaseAuthority.js";
+import { type MoltnetExecutionHost, type LocalMoltnetReleaseIdentity } from "./localMoltnetAuthority.js";
+/** Explicit operator override for a locally staged, authority-bound release. */
+export declare const MOLTNET_RELEASE_DIR_ENV = "SPAWNFILE_MOLTNET_RELEASE_DIR";
+/** Explicit development-only local archive authority; never consulted by production compiles. */
+export declare const MOLTNET_LOCAL_RELEASE_DIR_ENV = "SPAWNFILE_LOCAL_MOLTNET_RELEASE_DIR";
+export declare const MOLTNET_ALLOW_LOCAL_E2E_ENV = "SPAWNFILE_ALLOW_LOCAL_E2E";
 export declare const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
 export declare const MOLTNET_BINARY_NAMES: readonly ["moltnet"];
-export type MoltnetTargetArchitecture = "amd64" | "arm64";
+export declare const MOLTNET_RELEASE_IDENTITY_VERSION: "spawnfile.moltnet-release-identity.v1";
+export declare const MOLTNET_RELEASE_STAMP_VERSION: "spawnfile.moltnet-release-stamp.v1";
+export type { MoltnetTargetArchitecture } from "./moltnetReleaseAuthority.js";
+/** Re-exported so existing importers keep one shape; defined in the lowest layer. */
+export type { MoltnetBridgeCapabilities } from "./moltnetReleaseAuthority.js";
+interface MoltnetIdentityBase {
+    readonly architecture: MoltnetTargetArchitecture;
+    readonly asset: string;
+    readonly asset_sha256: `sha256:${string}`;
+    readonly capabilities: MoltnetBridgeCapabilities;
+    readonly version: typeof MOLTNET_RELEASE_IDENTITY_VERSION;
+}
+export interface PublishedMoltnetReleaseIdentity extends MoltnetIdentityBase {
+    readonly capabilities: MoltnetBridgeCapabilities;
+    readonly release_version: string;
+    readonly source_revision: string;
+}
+export type MoltnetReleaseIdentity = PublishedMoltnetReleaseIdentity | LocalMoltnetReleaseIdentity;
+export interface MoltnetBinaryStageOptions {
+    readonly architecture?: MoltnetTargetArchitecture;
+    /** Overrides the detected execution host for the local-build capability probe. Tests only. */
+    readonly executionHost?: MoltnetExecutionHost;
+    /** Explicit local source directory; bytes remain bound to trusted authority. */
+    readonly releaseDirectory?: string;
+}
 export declare const resolveMoltnetCliCommand: () => Promise<string>;
-export declare const stageMoltnetBinaries: (outputDirectory: string, options?: {
-    architecture?: MoltnetTargetArchitecture;
-}) => Promise<boolean>;
+export declare const stageMoltnetBinaries: (outputDirectory: string, options?: MoltnetBinaryStageOptions) => Promise<MoltnetReleaseIdentity>;

package/dist/compiler/moltnetBinaries.js

@@ -1,17 +1,29 @@
 import { execFile as execFileCallback } from "node:child_process";
+import { createHash } from "node:crypto";
 import path from "node:path";
-import { chmod } from "node:fs/promises";
+import { chmod, readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { ensureDirectory, fileExists } from "../filesystem/index.js";
 import { SpawnfileError } from "../shared/index.js";
+import { parseMoltnetBridgeCapabilities, parseTrustedMoltnetReleaseAuthority, readTrustedMoltnetReleaseAuthority, trustedMoltnetReleaseAsset } from "./moltnetReleaseAuthority.js";
+import { downloadTrustedMoltnetReleaseAsset } from "./moltnetReleaseDownload.js";
+import { readLocalMoltnetReleaseIdentity } from "./localMoltnetAuthority.js";
 const execFile = promisify(execFileCallback);
 const MOLTNET_CLI_ENV = "SPAWNFILE_MOLTNET_CLI";
-const MOLTNET_RELEASE_DIR_ENV = "SPAWNFILE_MOLTNET_RELEASE_DIR";
+/** Explicit operator override for a locally staged, authority-bound release. */
+export const MOLTNET_RELEASE_DIR_ENV = "SPAWNFILE_MOLTNET_RELEASE_DIR";
+/** Explicit development-only local archive authority; never consulted by production compiles. */
+export const MOLTNET_LOCAL_RELEASE_DIR_ENV = "SPAWNFILE_LOCAL_MOLTNET_RELEASE_DIR";
+export const MOLTNET_ALLOW_LOCAL_E2E_ENV = "SPAWNFILE_ALLOW_LOCAL_E2E";
 const MOLTNET_TARGET_ARCH_ENV = "SPAWNFILE_MOLTNET_TARGET_ARCH";
-const LOCAL_MOLTNET_CLI_PATH = path.resolve(process.cwd(), "moltnet", "bin", "moltnet");
 const MOLTNET_TARGET_OS = "linux";
 export const MOLTNET_BIN_DIRECTORY = "moltnet-bin";
 export const MOLTNET_BINARY_NAMES = ["moltnet"];
+export const MOLTNET_RELEASE_IDENTITY_VERSION = "spawnfile.moltnet-release-identity.v1";
+export const MOLTNET_RELEASE_STAMP_VERSION = "spawnfile.moltnet-release-stamp.v1";
+const SHA256 = /^[a-f0-9]{64}$/u;
+const REVISION = /^[a-f0-9]{40}$/u;
+const PINNED_VERSION = /^v?\d+\.\d+\.\d+(?:-\d+-g[a-f0-9]{7,40})?$/u;
 const normalizeTargetArchitecture = (architecture) => {
     switch (architecture) {
         case "amd64":
@@ -42,7 +54,120 @@ const resolveTargetArchitecture = (architecture) => {
             throw new SpawnfileError("compile_error", `Moltnet container installs do not support host architecture ${process.arch}`);
     }
 };
+/**
+ * The platform executing this compile, for the local-build capability probe.
+ *
+ * Deliberately NOT `resolveTargetArchitecture()`: that helper honours the
+ * `SPAWNFILE_MOLTNET_TARGET_ARCH` build-target override and falls back to
+ * `process.arch`, so passing it as the host made the host and the target the
+ * same value by construction and pinned the probe to its direct-exec branch.
+ * This reads the real host only, and reports `architecture: undefined` for a
+ * CPU that is not a nameable Moltnet target rather than throwing -- an
+ * unsupported host is not a compile error, it just cannot exec the binary
+ * directly.
+ *
+ * Private: this module's export surface is pinned by test.
+ */
+const resolveMoltnetExecutionHost = () => ({
+    ...(process.arch === "arm64"
+        ? { architecture: "arm64" }
+        : process.arch === "x64" ? { architecture: "amd64" } : {}),
+    platform: process.platform
+});
 const createReleaseAssetName = (architecture) => `moltnet_${MOLTNET_TARGET_OS}_${architecture}.tar.gz`;
+const createReleaseStampName = (architecture) => `moltnet_release_stamp_${architecture}.json`;
+const exactKeys = (value, keys) => Object.keys(value).sort().join("\0") === [...keys].sort().join("\0");
+const parseReleaseStamp = (raw, architecture) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new SpawnfileError("compile_error", "Moltnet release capability stamp is not valid JSON");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new SpawnfileError("compile_error", "Moltnet release capability stamp has an invalid shape");
+    }
+    const value = parsed;
+    const expectedKeys = [
+        "arch", "asset", "built_at", "capabilities", "pi_bridge", "sha256",
+        "source_revision", "stamp_version", "version"
+    ];
+    const capabilities = value.capabilities;
+    if (!exactKeys(value, expectedKeys)
+        || value.stamp_version !== MOLTNET_RELEASE_STAMP_VERSION
+        || value.arch !== architecture
+        || value.asset !== createReleaseAssetName(architecture)
+        || typeof value.built_at !== "string"
+        || !Number.isFinite(Date.parse(value.built_at))
+        || parseMoltnetBridgeCapabilities(capabilities) === null
+        || value.pi_bridge !== true
+        || typeof value.sha256 !== "string"
+        || !SHA256.test(value.sha256)
+        || typeof value.source_revision !== "string"
+        || !REVISION.test(value.source_revision)
+        || typeof value.version !== "string"
+        || !PINNED_VERSION.test(value.version)) {
+        throw new SpawnfileError("compile_error", `Moltnet release capability stamp must be strict, pinned, and assert only the pi-bridge capability for ${architecture}`);
+    }
+    const describedRevision = value.version.match(/-g([a-f0-9]{7,40})$/u)?.[1];
+    if (describedRevision && !value.source_revision.startsWith(describedRevision)) {
+        throw new SpawnfileError("compile_error", "Moltnet release version does not match its source revision");
+    }
+    return value;
+};
+const verifyReleaseIdentity = async (releaseDirectory, architecture, authority) => {
+    const trustedAuthority = parseTrustedMoltnetReleaseAuthority(authority);
+    const trustedAsset = trustedMoltnetReleaseAsset(trustedAuthority, architecture);
+    const asset = createReleaseAssetName(architecture);
+    const assetPath = path.join(releaseDirectory, asset);
+    const stampPath = path.join(releaseDirectory, createReleaseStampName(architecture));
+    if (!(await fileExists(assetPath))) {
+        throw new SpawnfileError("compile_error", `Moltnet release asset ${assetPath} does not exist`);
+    }
+    if (!(await fileExists(stampPath))) {
+        throw new SpawnfileError("compile_error", `Moltnet release asset ${asset} has no required capability stamp ${stampPath}`);
+    }
+    const stamp = parseReleaseStamp((await readFile(stampPath)).toString("utf8"), architecture);
+    const sha256 = createHash("sha256").update(await readFile(assetPath)).digest("hex");
+    if (stamp.sha256 !== sha256) {
+        throw new SpawnfileError("compile_error", `Moltnet release stamp sha256 does not match ${asset} (stale or tampered artifact)`);
+    }
+    if (stamp.version !== trustedAuthority.release_version
+        || stamp.source_revision !== trustedAuthority.source_revision
+        || stamp.asset !== trustedAsset.asset
+        || `sha256:${sha256}` !== trustedAsset.asset_sha256) {
+        throw new SpawnfileError("compile_error", `Moltnet release stamp and asset do not match trusted pinned authority for ${architecture}`);
+    }
+    return Object.freeze({
+        architecture,
+        asset,
+        asset_sha256: `sha256:${sha256}`,
+        capabilities: stamp.capabilities,
+        release_version: stamp.version,
+        source_revision: stamp.source_revision,
+        version: MOLTNET_RELEASE_IDENTITY_VERSION
+    });
+};
+const stageMoltnetReleaseAsset = async (outputDirectory, releaseAssetPath, identity) => {
+    const installDirectory = path.join(outputDirectory, MOLTNET_BIN_DIRECTORY);
+    await ensureDirectory(installDirectory);
+    try {
+        await execFile("tar", ["-C", installDirectory, "-xzf", releaseAssetPath]);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("compile_error", `Unable to extract Moltnet release asset ${releaseAssetPath}: ${reason}`);
+    }
+    for (const binaryName of MOLTNET_BINARY_NAMES) {
+        const binaryPath = path.join(installDirectory, binaryName);
+        if (!(await fileExists(binaryPath))) {
+            throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} did not contain ${binaryName}`);
+        }
+        await chmod(binaryPath, 0o755);
+    }
+    return identity;
+};
 const isCommandNotFoundError = (error) => typeof error === "object" &&
     error !== null &&
     "code" in error &&
@@ -67,6 +192,18 @@ const resolveConfiguredReleaseDirectory = async () => {
     }
     return configuredDirectory;
 };
+const resolveConfiguredLocalReleaseDirectory = async () => {
+    const configuredDirectory = process.env[MOLTNET_LOCAL_RELEASE_DIR_ENV]?.trim();
+    if (!configuredDirectory)
+        return null;
+    if (process.env[MOLTNET_ALLOW_LOCAL_E2E_ENV] !== "1") {
+        throw new SpawnfileError("compile_error", "Local Moltnet identity requires explicit SPAWNFILE_ALLOW_LOCAL_E2E=1 opt-in");
+    }
+    if (!path.isAbsolute(configuredDirectory) || !(await fileExists(configuredDirectory))) {
+        throw new SpawnfileError("compile_error", "Local Moltnet release directory is invalid");
+    }
+    return configuredDirectory;
+};
 const findPathMoltnetCli = async () => {
     try {
         await execFile("moltnet", ["version"]);
@@ -89,36 +226,46 @@ export const resolveMoltnetCliCommand = async () => {
     if (pathCli) {
         return pathCli;
     }
-    if (await fileExists(LOCAL_MOLTNET_CLI_PATH)) {
-        return validateMoltnetCli(LOCAL_MOLTNET_CLI_PATH, LOCAL_MOLTNET_CLI_PATH);
-    }
     return validateMoltnetCli("moltnet", "PATH");
 };
-export const stageMoltnetBinaries = async (outputDirectory, options = {}) => {
-    const releaseDirectory = await resolveConfiguredReleaseDirectory();
-    if (!releaseDirectory) {
-        return false;
+const stageMoltnetBinariesAtReleaseDirectory = async (outputDirectory, releaseDirectory, options = {}) => {
+    if (!path.isAbsolute(releaseDirectory) || !(await fileExists(releaseDirectory))) {
+        throw new SpawnfileError("compile_error", "Trusted Moltnet release directory is invalid");
     }
     const architecture = resolveTargetArchitecture(options.architecture);
+    const authority = await readTrustedMoltnetReleaseAuthority();
+    const identity = await verifyReleaseIdentity(releaseDirectory, architecture, authority);
     const releaseAssetPath = path.join(releaseDirectory, createReleaseAssetName(architecture));
-    if (!(await fileExists(releaseAssetPath))) {
-        throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} does not exist. Build it with \`cd moltnet && make release-assets\` or set ${MOLTNET_RELEASE_DIR_ENV}.`);
+    return stageMoltnetReleaseAsset(outputDirectory, releaseAssetPath, identity);
+};
+export const stageMoltnetBinaries = async (outputDirectory, options = {}) => {
+    const localReleaseDirectory = await resolveConfiguredLocalReleaseDirectory();
+    if (localReleaseDirectory) {
+        const architecture = resolveTargetArchitecture(options.architecture);
+        const identity = await readLocalMoltnetReleaseIdentity(localReleaseDirectory, architecture, options.executionHost ?? resolveMoltnetExecutionHost());
+        return stageMoltnetReleaseAsset(outputDirectory, path.join(localReleaseDirectory, createReleaseAssetName(architecture)), identity);
     }
-    const installDirectory = path.join(outputDirectory, MOLTNET_BIN_DIRECTORY);
-    await ensureDirectory(installDirectory);
-    try {
-        await execFile("tar", ["-C", installDirectory, "-xzf", releaseAssetPath]);
+    const releaseDirectory = options.releaseDirectory
+        ?? await resolveConfiguredReleaseDirectory();
+    if (releaseDirectory) {
+        return stageMoltnetBinariesAtReleaseDirectory(outputDirectory, releaseDirectory, { architecture: options.architecture });
     }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new SpawnfileError("compile_error", `Unable to extract Moltnet release asset ${releaseAssetPath}: ${reason}`);
+    const architecture = resolveTargetArchitecture(options.architecture);
+    const authority = await readTrustedMoltnetReleaseAuthority();
+    const trustedAsset = trustedMoltnetReleaseAsset(authority, architecture);
+    const downloaded = await downloadTrustedMoltnetReleaseAsset(authority, architecture);
+    try {
+        return await stageMoltnetReleaseAsset(outputDirectory, downloaded.assetPath, Object.freeze({
+            architecture,
+            asset: trustedAsset.asset,
+            asset_sha256: trustedAsset.asset_sha256,
+            capabilities: authority.capabilities,
+            release_version: authority.release_version,
+            source_revision: authority.source_revision,
+            version: MOLTNET_RELEASE_IDENTITY_VERSION
+        }));
     }
-    for (const binaryName of MOLTNET_BINARY_NAMES) {
-        const binaryPath = path.join(installDirectory, binaryName);
-        if (!(await fileExists(binaryPath))) {
-            throw new SpawnfileError("compile_error", `Moltnet release asset ${releaseAssetPath} did not contain ${binaryName}`);
-        }
-        await chmod(binaryPath, 0o755);
+    finally {
+        await downloaded.cleanup();
     }
-    return true;
 };

package/dist/compiler/moltnetClientConfig.js

@@ -24,7 +24,7 @@ const createAttachmentConfig = (node, artifacts, attachment, agentSlug) => {
         throw new SpawnfileError("compile_error", `Moltnet client config requires a resolved member id for ${node.name}`);
     }
     const serverPlan = findServerPlan(artifacts, attachment);
-    const auth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, agentSlug);
+    const auth = resolveMoltnetClientAuth(serverPlan.server, attachment.network, attachment.memberId, agentSlug, attachment.auth?.tokenId, node.runtime.name);
     return {
         agent_name: node.name,
         auth: {
@@ -38,7 +38,12 @@ const createAttachmentConfig = (node, artifacts, attachment, agentSlug) => {
             ? {
                 dms: {
                     enabled: attachment.dms.enabled,
-                    ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {})
+                    ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {}),
+                    ...(attachment.dms.allowedWakeSenders !== undefined
+                        ? {
+                            allowed_wake_senders: [...attachment.dms.allowedWakeSenders]
+                        }
+                        : {})
                 }
             }
             : {}),

package/dist/compiler/moltnetConfigLowering.d.ts

@@ -4,6 +4,8 @@ export interface MoltnetSecretPatch {
     jsonPath: string;
 }
 export interface MoltnetClientAuthPlan {
+    credentialAgentId?: string;
+    credentialId?: string;
     mode: "bearer" | "none" | "open";
     registration?: "disabled" | "open" | "token";
     staticToken?: boolean;
@@ -11,6 +13,7 @@ export interface MoltnetClientAuthPlan {
     tokenPath?: string;
 }
 export interface MoltnetNativeRoomConfig {
+    federation?: "all" | "none" | string[];
     id: string;
     members: string[];
     name?: string;
@@ -31,16 +34,30 @@ type ManagedMoltnetStore = Extract<TeamNetworkServer, {
 export declare const createMoltnetOpenTokenDirectory: (agentSlug: string) => string;
 export declare const createMoltnetOpenTokenPath: (networkId: string, memberId: string, agentSlug?: string) => string;
 export declare const createMoltnetNetworkStateDirectory: (networkId: string) => string;
+export declare const createMoltnetDaimonReceiptStorePath: (networkId: string, memberId: string) => string;
 export declare const createDefaultMoltnetStorePath: (networkId: string, kind: "json" | "sqlite", mountPath?: string) => string;
 export declare const resolveMoltnetStorePath: (networkId: string, store: ManagedMoltnetStore) => string | null;
 export declare const resolveMoltnetStorePersistenceMountPath: (networkId: string, store: ManagedMoltnetStore) => string | null;
 export declare const createMoltnetServerConfigPath: (serverId: string) => string;
+/**
+ * Dedicated causal-log subdirectory, a SIBLING of (never the same directory
+ * as) the server's own Moltnet.json config file. Deliberately kept separate
+ * so a persistent volume mounted here (to survive container teardown/
+ * restart, see moltnetArtifacts.ts's causal persistent mount) never masks a
+ * rebuilt image's freshly-baked Moltnet.json — which carries secrets
+ * patched in at container start via secretPatches — with a stale copy left
+ * over in a prior run's volume. Takes the already-container-absolute
+ * `configPath` (MoltnetServerPlan.configPath, post toContainerRootfsPath),
+ * not the rootfs-prefixed emit path.
+ */
+export declare const createMoltnetCausalDirectory: (configPath: string) => string;
+export declare const createMoltnetCausalEventsPath: (configPath: string) => string;
 export declare const createMoltnetNodeConfigPath: (teamSlug: string, networkId: string, agentId: string) => string;
 export declare const renderMoltnetListenAddr: (server: Extract<TeamNetworkServer, {
     mode: "managed";
 }>) => string;
 export declare const resolveMoltnetBaseUrl: (server: TeamNetworkServer) => string;
-export declare const resolveMoltnetClientAuth: (server: TeamNetworkServer, networkId: string, memberId: string, agentSlug?: string) => MoltnetClientAuthPlan;
+export declare const resolveMoltnetClientAuth: (server: TeamNetworkServer, networkId: string, memberId: string, agentSlug?: string, attachmentTokenId?: string, runtimeName?: string) => MoltnetClientAuthPlan;
 export declare const createMoltnetNativeServerConfig: ({ networkId, networkName, rooms, server }: MoltnetNativeServerConfigInput) => {
     config: Record<string, unknown>;
     secretPatches: MoltnetSecretPatch[];