spawnfile 0.1.13 → 0.1.17

package/dist/report/types.d.ts

@@ -12,6 +12,11 @@ export interface DiagnosticReport {
 }
 export interface ContainerRuntimeInstanceReport {
     config_path: string;
+    /** Per pi/daimon agent (keyed by node id, e.g. "agent:eleanor"): the resolved pi
+     * engine kind (see `PI_ENGINE_KINDS` in `src/runtime/pi/appTemplate.ts`, e.g.
+     * "scripted"), so a scripted-engine run is disclosable on the compile report rather
+     * than an invisible test-only branch. Only pi/daimon runtime instances populate this. */
+    engine_by_node_id?: Record<string, string>;
     home_path: string | null;
     id: string;
     internal_port?: number | null;
@@ -20,39 +25,181 @@ export interface ContainerRuntimeInstanceReport {
     node_ids?: string[];
     published_port?: number | null;
     runtime: string;
+    /** Per pi/daimon agent (keyed by node id, e.g. "agent:eleanor"): the id of its daimon
+     * telemetry persistent mount (see `daimonTelemetryArtifacts.ts`), so
+     * `artifactsExportPlan.ts` can egress `causal.jsonl` from that agent's durable volume
+     * instead of `docker cp`ing it out of the (possibly already-gone) live container. */
+    telemetry_mount_ids?: Record<string, string>;
     workspace_path?: string;
 }
 export interface ContainerWorkspaceResourceReport {
     backing_path: string;
     id: string;
-    kind: "git" | "volume";
+    kind: "bundle" | "git" | "volume";
     link_path: string;
     mode: "mutable" | "readonly";
     mount: string;
+    mount_path: string;
+    replacement_sentinel?: {
+        path: string;
+        result: "verified_on_startup";
+    };
+    resolved_identity: string;
     sharing: "per_agent" | "team";
+    volume_name: string | null;
 }
 export interface ContainerPersistentMountReport {
+    /**
+     * The author's own volume name, when one was declared (a workspace resource
+     * `name`, a `store.persistence.name`, a memory bank's `persistence.name`).
+     * Present only when declared; `volume_name` equals it in that case. It is
+     * carried separately because it is the one part of the resolved name that is
+     * portable: it belongs to the declaration, not to the creator's plan root or
+     * deployment lineage, so a published image can honour it verbatim while a
+     * derived name must be re-derived per deployment.
+     */
+    declared_volume_name?: string;
     id: string;
+    lifecycle?: "exclusive-reattach";
     mount_path: string;
     reason: string;
     volume_name: string;
 }
+export interface ContainerMemoryStoreReport {
+    kind: "json" | "memory" | "postgres" | "sqlite";
+    dsn_secret?: string;
+    path?: string;
+    persistence?: "durable" | "ephemeral";
+    persistent_mount_id?: string;
+}
+export interface ContainerMemoryIndexReport {
+    graph: {
+        enabled: boolean;
+        kind?: "entity_graph" | "temporal_kg";
+    };
+    lexical: {
+        enabled: boolean;
+        engine?: "bm25" | "sqlite_fts";
+    };
+    rerank: {
+        enabled: boolean;
+    };
+    vector: {
+        enabled: boolean;
+        base_url?: string;
+        dimensions?: number;
+        model?: string;
+        provider?: "ollama";
+        timeout_ms?: number;
+    };
+}
+export interface ContainerMemoryConsolidationReport {
+    mode: "disabled" | "on_threshold" | "scheduled";
+    schedule?: string;
+    summarize_after_events?: number;
+}
+export interface ContainerMemoryRetentionReport {
+    forgetting: "decay" | "manual" | "ttl";
+    ttl?: string;
+}
+export type ContainerMemoryTransport = "degraded_mcp" | "degraded" | "direct" | "mcp" | "unsupported";
+export interface ContainerMemoryReport {
+    id: string;
+    declaring_node_id: string;
+    accessible_node_ids: string[];
+    store: ContainerMemoryStoreReport;
+    index: ContainerMemoryIndexReport;
+    consolidation: ContainerMemoryConsolidationReport;
+    retention: ContainerMemoryRetentionReport;
+    transport_by_node_id: Record<string, ContainerMemoryTransport>;
+}
+interface ContainerMemoryScope {
+    qualifier: string;
+    scope: "global" | "team" | "room";
+}
+interface CompileReportMoltnetRoomBinding {
+    context_key: string;
+    derivation: {
+        member_position: number;
+        rule: string;
+    };
+    member_slot: string;
+    roster: string;
+    team_id: string;
+    team_doc: string;
+    session_key: string;
+    memory: {
+        durable_scope: {
+            qualifier: string;
+            scope: "team";
+        };
+        ephemeral_scope: {
+            qualifier: string;
+            scope: "room";
+        };
+    };
+}
+interface CompileReportActiveSchedule {
+    context_key: string;
+    derivation: {
+        rule: string;
+    };
+    environment_key: string;
+    memory: {
+        durable_scope: ContainerMemoryScope;
+    };
+    session_key: string;
+}
+interface CompileReportActiveDream {
+    context_key: string;
+    environment_key: string;
+    memory: {
+        durable_scope: {
+            qualifier: string;
+            scope: "global" | "team";
+        };
+    };
+    session_key_template: string;
+}
+export interface CompileReportActiveEnvironments {
+    moltnet?: Record<string, {
+        rooms: Record<string, CompileReportMoltnetRoomBinding>;
+    }>;
+    schedules?: Record<string, CompileReportActiveSchedule>;
+    dreams?: Record<string, CompileReportActiveDream>;
+}
 export interface ContainerPortMappingReport {
     internal_port: number;
     published_port: number;
 }
 export interface ContainerMoltnetNodePlanSummary {
     config_path: string;
+    credential_agent_id?: string;
+    credential_id?: string;
+    credential_secret?: string;
+    member_id?: string;
     network_id: string;
 }
 export interface ContainerMoltnetServerPlanSummary {
+    agent_registration?: "disabled" | "open" | "token";
     auth_mode?: "bearer" | "none" | "open";
+    auth_tokens?: Array<{
+        agents: string[];
+        id: string;
+        scopes: Array<"admin" | "attach" | "observe" | "pair" | "write">;
+        secret: string;
+    }>;
     base_url: string;
     config_path?: string;
+    debug_events?: boolean;
     direct_messages?: boolean;
+    human_ingress?: boolean;
     id: string;
     mode: "external" | "managed";
     network_id: string;
+    network_name?: string;
+    operator_agent_id?: string;
+    operator_token_id?: string;
     operator_token_secret?: string;
     port?: number;
     public_read?: boolean;
@@ -63,14 +210,32 @@ export interface ContainerMoltnetServerPlanSummary {
         write_policy?: "members" | "operators" | "registered_agents";
     }>;
     store_kind?: "json" | "memory" | "postgres" | "sqlite";
+    trust_forwarded_proto?: boolean;
 }
 export interface ContainerMoltnetPlanSummary {
     node_plans: ContainerMoltnetNodePlanSummary[];
+    release?: {
+        architecture: "amd64" | "arm64";
+        asset: string;
+        asset_sha256: `sha256:${string}`;
+        capabilities: readonly ["pi-bridge"] | readonly ["daimon-bridge", "pi-bridge"];
+        development?: {
+            mode: "local-development";
+            non_production: true;
+            unsigned: true;
+            unpublished: true;
+        };
+        release_version?: string;
+        source_revision?: string;
+        source_sha256?: `sha256:${string}`;
+        version: "spawnfile.moltnet-release-identity.v1";
+    };
     server_plans: ContainerMoltnetServerPlanSummary[];
 }
 export interface NodeReport {
     capabilities: CapabilityReport[];
     diagnostics: DiagnosticReport[];
+    active_environments?: CompileReportActiveEnvironments;
     id: string;
     kind: "agent" | "team";
     output_dir: string | null;
@@ -84,8 +249,14 @@ export interface ContainerReport {
     entrypoint: string;
     env_example: string;
     internal_ports?: number[];
+    local_daimon_runtime?: {
+        capability_receipt_sha256: string;
+        image_reference: string;
+        registry_authority: string;
+    };
     model_secrets_required: string[];
     moltnet?: ContainerMoltnetPlanSummary;
+    memory?: ContainerMemoryReport[];
     port_mappings?: ContainerPortMappingReport[];
     ports: number[];
     published_ports?: number[];
@@ -108,3 +279,4 @@ export interface CompileReport {
     root: string;
     spawnfile_version: "0.1";
 }
+export {};

package/dist/runtime/common.d.ts

@@ -1,12 +1,74 @@
 import type { ResolvedAgentNode, ResolvedDocument, ResolvedSkill } from "../compiler/types.js";
 import type { CapabilityReport, DiagnosticReport } from "../report/index.js";
 import { EmittedFile } from "./types.js";
+/**
+ * Container env var name every generated runtime container is stamped with,
+ * so every authority (moltnet, mneme, daimon, and root's own runtime
+ * containers) agrees on a single run identifier for causal event envelopes
+ * (see specs/CAUSAL.md). Adapters and containers must read run_id from this
+ * environment variable — never from model output.
+ */
+export declare const NOOPOLIS_RUN_ID_ENV = "NOOPOLIS_RUN_ID";
+/**
+ * Resolves the shared NOOPOLIS_RUN_ID value from the host/process
+ * environment. Returns undefined when unset so callers can decide whether
+ * to omit the variable entirely rather than stamp an empty value.
+ */
+export declare const resolveNoopolisRunId: (env?: NodeJS.ProcessEnv) => string | undefined;
+/**
+ * Ensures `env` carries a NOOPOLIS_RUN_ID: returns the host-provided value
+ * untouched when one is already set, otherwise generates a fresh run id,
+ * stamps it onto `env`, and returns it. This is the one place a run id is
+ * ever generated — every other reader (createRuntimeContainerEnv here,
+ * mneme's resolveCausalRunId, daimon's resolveRunId, moltnet's
+ * causalRunIDEnv lookup) only ever reads what is already in the process
+ * env, so a run id absent from the host env would otherwise leave moltnet
+ * causal events with no run_id to stamp (see specs/CAUSAL.md).
+ *
+ * Callers: only the `run`/`up` execution entrypoints (`runProject.ts`,
+ * `upProject.ts`) and their equivalents in opt-in E2E harnesses that build
+ * a container directly (e.g. `src/e2e/officeSim.ts`) — never
+ * `compileProject.ts`/`buildProject.ts` themselves, which must stay
+ * deterministic functions of their inputs. Called once per run/up
+ * invocation, before the compile step, so every authority container
+ * compiled during that invocation is stamped with the same real id.
+ */
+export declare const ensureNoopolisRunId: (env?: NodeJS.ProcessEnv) => string;
 export declare const createCapability: (key: string, outcome: CapabilityReport["outcome"], message?: string) => CapabilityReport;
 export declare const createDiagnostic: (level: DiagnosticReport["level"], message: string) => DiagnosticReport;
 export declare const createDocumentFiles: (baseDirectory: string, documents: ResolvedDocument[]) => EmittedFile[];
-export declare const createSkillFiles: (baseDirectory: string, skills: ResolvedSkill[]) => EmittedFile[];
+/**
+ * Skill roots for the runtimes whose declared skills are read by an external
+ * coding-agent CLI engine (`daimon` and `pi`). `.codex/skills` is Codex's own
+ * workspace discovery root; `.agents/skills` is the generic cross-engine root
+ * that grok, agy, and every other file-reading CLI engine use. Both entries
+ * are required and the two emitted files are byte-identical on purpose — this
+ * mirrors the Moltnet skill install, which is the working reference: Spawnfile
+ * runs `moltnet skill install --runtime codex` for these runtimes and Moltnet
+ * writes the same skill to both roots (`resolveMoltnetWorkspaceLayout` in
+ * `src/compiler/moltnetClientConfig.ts`, `installMoltnetSkill` in
+ * `moltnet/cmd/moltnet/skill.go`). A plain `workspace/skills/` root is read by
+ * no engine these two runtimes can host, so anything emitted there is invisible.
+ */
+export declare const CLI_ENGINE_SKILL_BASE_DIRECTORIES: readonly string[];
+/**
+ * Skill root for the runtimes that own their own skill loader and read the
+ * workspace `skills/` directory directly (`openclaw`, `picoclaw`). Moltnet
+ * installs its skill to the same place for those runtimes.
+ */
+export declare const WORKSPACE_SKILL_BASE_DIRECTORY = "workspace/skills";
+/**
+ * Lowers declared skills into emitted `SKILL.md` files. `baseDirectory`
+ * accepts a list because a runtime can need the same skill under more than
+ * one discovery root (see `CLI_ENGINE_SKILL_BASE_DIRECTORIES`); the emission
+ * order is root-major so a generated workspace lists each root's skills
+ * together and stays deterministic.
+ */
+export declare const createSkillFiles: (baseDirectory: string | readonly string[], skills: ResolvedSkill[]) => EmittedFile[];
 export declare const createAgentCapabilities: (node: ResolvedAgentNode, options?: {
     mcpOutcome?: CapabilityReport["outcome"];
+    memoryMessage?: string;
+    memoryOutcome?: CapabilityReport["outcome"];
     moltnetMessage?: string;
     moltnetOutcome?: CapabilityReport["outcome"];
     sandboxOutcome?: CapabilityReport["outcome"];

package/dist/runtime/common.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 const ROLE_FILE_NAMES = {
     heartbeat: "HEARTBEAT.md",
     identity: "IDENTITY.md",
@@ -5,6 +6,47 @@ const ROLE_FILE_NAMES = {
     soul: "SOUL.md",
     system: "AGENTS.md"
 };
+/**
+ * Container env var name every generated runtime container is stamped with,
+ * so every authority (moltnet, mneme, daimon, and root's own runtime
+ * containers) agrees on a single run identifier for causal event envelopes
+ * (see specs/CAUSAL.md). Adapters and containers must read run_id from this
+ * environment variable — never from model output.
+ */
+export const NOOPOLIS_RUN_ID_ENV = "NOOPOLIS_RUN_ID";
+/**
+ * Resolves the shared NOOPOLIS_RUN_ID value from the host/process
+ * environment. Returns undefined when unset so callers can decide whether
+ * to omit the variable entirely rather than stamp an empty value.
+ */
+export const resolveNoopolisRunId = (env = process.env) => env[NOOPOLIS_RUN_ID_ENV]?.trim() || undefined;
+/**
+ * Ensures `env` carries a NOOPOLIS_RUN_ID: returns the host-provided value
+ * untouched when one is already set, otherwise generates a fresh run id,
+ * stamps it onto `env`, and returns it. This is the one place a run id is
+ * ever generated — every other reader (createRuntimeContainerEnv here,
+ * mneme's resolveCausalRunId, daimon's resolveRunId, moltnet's
+ * causalRunIDEnv lookup) only ever reads what is already in the process
+ * env, so a run id absent from the host env would otherwise leave moltnet
+ * causal events with no run_id to stamp (see specs/CAUSAL.md).
+ *
+ * Callers: only the `run`/`up` execution entrypoints (`runProject.ts`,
+ * `upProject.ts`) and their equivalents in opt-in E2E harnesses that build
+ * a container directly (e.g. `src/e2e/officeSim.ts`) — never
+ * `compileProject.ts`/`buildProject.ts` themselves, which must stay
+ * deterministic functions of their inputs. Called once per run/up
+ * invocation, before the compile step, so every authority container
+ * compiled during that invocation is stamped with the same real id.
+ */
+export const ensureNoopolisRunId = (env = process.env) => {
+    const existing = resolveNoopolisRunId(env);
+    if (existing) {
+        return existing;
+    }
+    const generated = `run-${randomUUID().replaceAll("-", "")}`;
+    env[NOOPOLIS_RUN_ID_ENV] = generated;
+    return generated;
+};
 export const createCapability = (key, outcome, message = "") => ({
     key,
     message,
@@ -20,10 +62,40 @@ export const createDocumentFiles = (baseDirectory, documents) => documents.map((
         ? `${baseDirectory}/${ROLE_FILE_NAMES[document.role]}`
         : `${baseDirectory}/extras/${document.role.replace(/^extras\./, "")}.md`
 }));
-export const createSkillFiles = (baseDirectory, skills) => skills.map((skill) => ({
+/**
+ * Skill roots for the runtimes whose declared skills are read by an external
+ * coding-agent CLI engine (`daimon` and `pi`). `.codex/skills` is Codex's own
+ * workspace discovery root; `.agents/skills` is the generic cross-engine root
+ * that grok, agy, and every other file-reading CLI engine use. Both entries
+ * are required and the two emitted files are byte-identical on purpose — this
+ * mirrors the Moltnet skill install, which is the working reference: Spawnfile
+ * runs `moltnet skill install --runtime codex` for these runtimes and Moltnet
+ * writes the same skill to both roots (`resolveMoltnetWorkspaceLayout` in
+ * `src/compiler/moltnetClientConfig.ts`, `installMoltnetSkill` in
+ * `moltnet/cmd/moltnet/skill.go`). A plain `workspace/skills/` root is read by
+ * no engine these two runtimes can host, so anything emitted there is invisible.
+ */
+export const CLI_ENGINE_SKILL_BASE_DIRECTORIES = [
+    "workspace/.agents/skills",
+    "workspace/.codex/skills"
+];
+/**
+ * Skill root for the runtimes that own their own skill loader and read the
+ * workspace `skills/` directory directly (`openclaw`, `picoclaw`). Moltnet
+ * installs its skill to the same place for those runtimes.
+ */
+export const WORKSPACE_SKILL_BASE_DIRECTORY = "workspace/skills";
+/**
+ * Lowers declared skills into emitted `SKILL.md` files. `baseDirectory`
+ * accepts a list because a runtime can need the same skill under more than
+ * one discovery root (see `CLI_ENGINE_SKILL_BASE_DIRECTORIES`); the emission
+ * order is root-major so a generated workspace lists each root's skills
+ * together and stays deterministic.
+ */
+export const createSkillFiles = (baseDirectory, skills) => (typeof baseDirectory === "string" ? [baseDirectory] : baseDirectory).flatMap((directory) => skills.map((skill) => ({
     content: skill.content,
-    path: `${baseDirectory}/${skill.name}/SKILL.md`
-}));
+    path: `${directory}/${skill.name}/SKILL.md`
+})));
 export const createAgentCapabilities = (node, options = {}) => {
     const capabilities = [];
     for (const document of node.docs) {
@@ -35,6 +107,19 @@ export const createAgentCapabilities = (node, options = {}) => {
     for (const server of node.mcpServers) {
         capabilities.push(createCapability(`mcp.${server.name}`, options.mcpOutcome ?? "supported"));
     }
+    const memoryAccess = node.memoryAccess ?? [];
+    if (memoryAccess.length > 0) {
+        const uniqueBanks = new Map(memoryAccess.map((access) => [
+            `${access.source}:${access.bank.id}`,
+            access.bank
+        ]));
+        const outcome = options.memoryOutcome ?? "supported";
+        const message = options.memoryMessage ?? "Memory access is available to this runtime";
+        capabilities.push(createCapability("memory", outcome, message));
+        for (const bank of [...uniqueBanks.values()].sort((left, right) => left.id.localeCompare(right.id))) {
+            capabilities.push(createCapability(`memory.${bank.id}`, outcome, message));
+        }
+    }
     if (node.execution?.model) {
         capabilities.push(createCapability("execution.model", "supported"));
     }

package/dist/runtime/container.d.ts

@@ -1,9 +1,36 @@
+import { type RuntimeContainerPackageOverrides } from "./containerPackageOverrides.js";
 export declare const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
 export interface RuntimeInstallRecipe {
     baseImage?: string;
     commands: string[];
     copyCommands: string[];
+    /**
+     * Container environment variables this recipe's container must be
+     * started with. Always includes NOOPOLIS_RUN_ID (see
+     * src/runtime/common.ts) when a run id is available, so every authority
+     * container stamps causal events with the same run_id — never a value
+     * read from model output.
+     */
+    env: Record<string, string>;
     runtimeName: string;
     runtimeRoot: string;
 }
-export declare const createRuntimeInstallRecipe: (runtimeName: string) => Promise<RuntimeInstallRecipe>;
+/**
+ * Builds the shared container env assembly injected into every generated
+ * runtime install recipe. Currently just NOOPOLIS_RUN_ID, sourced from the
+ * host/compile process environment; omitted entirely when unset rather
+ * than stamping an empty value.
+ */
+export declare const createRuntimeContainerEnv: (env?: NodeJS.ProcessEnv) => Record<string, string>;
+export interface RuntimeInstallRecipeOptions {
+    /**
+     * Compile-time-only local overrides for this runtime's install npm
+     * packages (see src/runtime/containerPackageOverrides.ts and
+     * src/compiler/containerPackageOverrides.ts). Never set during a
+     * standard compile; only opt-in local/E2E harnesses populate this, and
+     * only for the exact package names they override — every other package
+     * in the recipe keeps its pinned registry `name@version` spec.
+     */
+    packageOverrides?: RuntimeContainerPackageOverrides;
+}
+export declare const createRuntimeInstallRecipe: (runtimeName: string, options?: RuntimeInstallRecipeOptions) => Promise<RuntimeInstallRecipe>;

package/dist/runtime/container.js

@@ -1,14 +1,34 @@
 import { SpawnfileError } from "../shared/index.js";
+import { NOOPOLIS_RUN_ID_ENV, resolveNoopolisRunId } from "./common.js";
+import { createVendorCopyCommand, needsVendorCopyCommand, resolveInstallPackageSpec } from "./containerPackageOverrides.js";
 import { resolveRuntimeInstallSelection } from "./install.js";
+import { DAIMON_LOCAL_RUNTIME_IDENTITY_ENV, loadLocalDaimonRuntimeIdentity } from "./localDaimonAuthority.js";
+import { DAIMON_CONTRACT_MANIFEST_SHA256, DAIMON_GROK_ENGINE_BROKER } from "./daimon/contractManifest.js";
+import { DAIMON_WAKE_FUSE_DIRECTORY, DAIMON_WAKE_FUSE_DIRECTORY_ENV } from "./daimon/config.js";
 export const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
 const PI_RUNTIME_BASE_IMAGE_ENV = "SPAWNFILE_PI_RUNTIME_BASE_IMAGE";
-const DAIMON_RUNTIME_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_IMAGE";
-const DAIMON_RUNTIME_BASE_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_BASE_IMAGE";
+const LEGACY_DAIMON_RUNTIME_IMAGE_ENV = "SPAWNFILE_DAIMON_RUNTIME_IMAGE";
+const LEGACY_DAIMON_RUNTIME_CAPABILITY_RECEIPT_ENV = "SPAWNFILE_DAIMON_RUNTIME_CAPABILITY_RECEIPT";
+const DAIMON_CAPABILITY_RECEIPT_FILE = "capability-receipt.json";
 const OPENCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_OPENCLAW_RUNTIME_IMAGE";
 const PICOCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_PICOCLAW_RUNTIME_IMAGE";
+const DAIMON_PACKAGE_NAME = "@noopolis/daimon";
+const PI_DAIMON_PACKAGE_VERSION = "0.1.2";
+const MNEME_PACKAGE_NAME = "@noopolis/mneme";
+const MNEME_PACKAGE_VERSION = "0.1.1";
 const PI_AI_PACKAGE_NAME = "@earendil-works/pi-ai";
 const PI_CODING_AGENT_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-const PI_PACKAGE_VERSION = "0.79.9";
+const PI_PACKAGE_VERSION = "0.79.10";
+/**
+ * Builds the shared container env assembly injected into every generated
+ * runtime install recipe. Currently just NOOPOLIS_RUN_ID, sourced from the
+ * host/compile process environment; omitted entirely when unset rather
+ * than stamping an empty value.
+ */
+export const createRuntimeContainerEnv = (env = process.env) => {
+    const runId = resolveNoopolisRunId(env);
+    return runId ? { [NOOPOLIS_RUN_ID_ENV]: runId } : {};
+};
 const assertArtifactInstallSelection = (runtimeName, selection) => {
     if (selection.kind !== "source_repo") {
         return;
@@ -24,10 +44,40 @@ const resolveRuntimeImageRef = (envName, selection) => process.env[envName]?.tri
     (selection.kind === "container_image"
         ? `${selection.image}:${selection.tag}`
         : undefined);
-export const createRuntimeInstallRecipe = async (runtimeName) => {
+/**
+ * Daimon is distributed only as a generic, source-free runtime image. A
+ * local-development authority is deliberately narrow: it must be an explicit
+ * generated identity file naming the approved loopback registry repository by
+ * manifest digest plus the exact embedded receipt digest. Raw image/receipt
+ * overrides, mutable tags, checkouts, and host-installed CLIs are rejected.
+ */
+const resolveDaimonRuntimeImageRef = async (selection) => {
+    if (selection.kind !== "container_image" ||
+        !selection.digest ||
+        !selection.capabilityReceipt) {
+        throw new SpawnfileError("runtime_error", "Daimon organization runtime v1 requires a pinned generic Daimon runtime image");
+    }
+    const pinnedImage = `${selection.image}@${selection.digest}`;
+    if (process.env[LEGACY_DAIMON_RUNTIME_IMAGE_ENV]?.trim() ||
+        process.env[LEGACY_DAIMON_RUNTIME_CAPABILITY_RECEIPT_ENV]?.trim()) {
+        throw new SpawnfileError("runtime_error", `Raw Daimon runtime image overrides are disabled; use ${DAIMON_LOCAL_RUNTIME_IDENTITY_ENV}`);
+    }
+    const identityPath = process.env[DAIMON_LOCAL_RUNTIME_IDENTITY_ENV]?.trim();
+    if (identityPath) {
+        const identity = await loadLocalDaimonRuntimeIdentity(identityPath);
+        return { capabilityReceipt: identity.capabilityReceipt, image: identity.imageReference };
+    }
+    if (selection.contractManifestSha256 !== DAIMON_CONTRACT_MANIFEST_SHA256) {
+        throw new SpawnfileError("runtime_error", "Selected Daimon runtime image does not attest the compiler's exact contract manifest; build and select a matching local artifact or pin a published compatible release");
+    }
+    return { capabilityReceipt: selection.capabilityReceipt, image: pinnedImage };
+};
+export const createRuntimeInstallRecipe = async (runtimeName, options = {}) => {
     const selection = await resolveRuntimeInstallSelection(runtimeName);
     assertArtifactInstallSelection(runtimeName, selection);
     const installRoot = `${RUNTIME_INSTALL_ROOT}/${runtimeName}`;
+    const containerEnv = createRuntimeContainerEnv();
+    const packageOverrides = options.packageOverrides;
     switch (runtimeName) {
         case "openclaw": {
             const openClawRuntimeImage = resolveRuntimeImageRef(OPENCLAW_RUNTIME_IMAGE_ENV, selection);
@@ -35,6 +85,7 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                 return {
                     commands: [],
                     copyCommands: [createRuntimeImageCopyCommand(openClawRuntimeImage, installRoot)],
+                    env: containerEnv,
                     runtimeName,
                     runtimeRoot: installRoot
                 };
@@ -47,6 +98,7 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                     `npm install -g --omit=dev --no-fund --no-audit ${selection.packageName}@${selection.version}`
                 ],
                 copyCommands: [],
+                env: containerEnv,
                 runtimeName,
                 runtimeRoot: `/usr/local/lib/node_modules/${selection.packageName}`
             };
@@ -59,6 +111,7 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                         `mkdir -p /usr/local/bin && ln -sf ${installRoot}/bin/picoclaw /usr/local/bin/picoclaw`
                     ],
                     copyCommands: [createRuntimeImageCopyCommand(picoClawRuntimeImage, installRoot)],
+                    env: containerEnv,
                     runtimeName,
                     runtimeRoot: installRoot
                 };
@@ -69,38 +122,28 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
             return {
                 commands: createPicoClawArchiveInstallCommands(installRoot, selection),
                 copyCommands: [],
+                env: containerEnv,
                 runtimeName,
                 runtimeRoot: installRoot
             };
         }
         case "daimon": {
-            const daimonRuntimeImage = process.env[DAIMON_RUNTIME_IMAGE_ENV]?.trim() ||
-                process.env[DAIMON_RUNTIME_BASE_IMAGE_ENV]?.trim() ||
-                (selection.kind === "container_image"
-                    ? `${selection.image}:${selection.tag}`
-                    : undefined);
-            if (daimonRuntimeImage) {
-                return {
-                    commands: [],
-                    copyCommands: [createRuntimeImageCopyCommand(daimonRuntimeImage, installRoot)],
-                    runtimeName,
-                    runtimeRoot: installRoot
-                };
-            }
-            if (selection.kind !== "npm") {
-                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
-            }
-            const npmPackages = [
-                `${selection.packageName}@${selection.version}`,
-                `${PI_CODING_AGENT_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`,
-                `${PI_AI_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`
-            ];
+            const daimonRuntime = await resolveDaimonRuntimeImageRef(selection);
             return {
                 commands: [
-                    `mkdir -p ${installRoot}`,
-                    `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
+                    `test -f ${installRoot}/${DAIMON_CAPABILITY_RECEIPT_FILE} && actual="$(sha256sum ${installRoot}/${DAIMON_CAPABILITY_RECEIPT_FILE} | awk '{print "sha256:" $1}')" && test "$actual" = ${JSON.stringify(daimonRuntime.capabilityReceipt)}`,
+                    `test -f ${installRoot}/contract-manifest.json && test -f ${installRoot}/contract-manifest.sha256 && manifest="$(cat ${installRoot}/contract-manifest.sha256)" && test "$manifest" = ${JSON.stringify(DAIMON_CONTRACT_MANIFEST_SHA256)} && test "$(sha256sum ${installRoot}/contract-manifest.json | awk '{print "sha256:" $1}')" = "$manifest" && node -e 'const fs=require("fs");const r=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));if(r.manifest_sha256!==process.argv[2])process.exit(1)' ${installRoot}/${DAIMON_CAPABILITY_RECEIPT_FILE} "$manifest"`,
+                    `ln -sf ${installRoot}/bin/daimon-runtime /usr/local/bin/daimon-runtime`,
+                    `ln -sf ${installRoot}/bin/codex /usr/local/bin/codex`,
+                    `install -o root -g root -m 0555 ${installRoot}/bin/grok /usr/local/bin/grok && arch="$(dpkg --print-architecture)" && case "$arch" in amd64) expected=${DAIMON_GROK_ENGINE_BROKER.grokCliArtifacts.x64.sha256} ;; arm64) expected=${DAIMON_GROK_ENGINE_BROKER.grokCliArtifacts.arm64.sha256} ;; *) exit 1 ;; esac && test "$(sha256sum /usr/local/bin/grok | awk '{print $1}')" = "$expected"`,
+                    `ln -sf ${installRoot}/bin/agy /usr/local/bin/agy`,
+                    `mkdir -p /opt/daimon/bin && install -o root -g root -m 0555 ${installRoot}/bin/daimon-engine-broker /opt/daimon/bin/daimon-engine-broker && arch="$(dpkg --print-architecture)" && case "$arch" in amd64) expected=${DAIMON_GROK_ENGINE_BROKER.artifacts.x64Sha256} ;; arm64) expected=${DAIMON_GROK_ENGINE_BROKER.artifacts.arm64Sha256} ;; *) exit 1 ;; esac && test "$(sha256sum /opt/daimon/bin/daimon-engine-broker | awk '{print $1}')" = "$expected"`
                 ],
-                copyCommands: [],
+                copyCommands: [createRuntimeImageCopyCommand(daimonRuntime.image, installRoot)],
+                env: {
+                    ...containerEnv,
+                    [DAIMON_WAKE_FUSE_DIRECTORY_ENV]: DAIMON_WAKE_FUSE_DIRECTORY
+                },
                 runtimeName,
                 runtimeRoot: installRoot
             };
@@ -111,6 +154,8 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
             }
             const prebuiltBaseImage = process.env[PI_RUNTIME_BASE_IMAGE_ENV]?.trim() || undefined;
             const npmPackages = [
+                resolveInstallPackageSpec(DAIMON_PACKAGE_NAME, PI_DAIMON_PACKAGE_VERSION, packageOverrides),
+                resolveInstallPackageSpec(MNEME_PACKAGE_NAME, MNEME_PACKAGE_VERSION, packageOverrides),
                 `${selection.packageName}@${selection.version}`,
                 `${PI_AI_PACKAGE_NAME}@${selection.version}`
             ];
@@ -122,7 +167,11 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                         `mkdir -p ${installRoot}`,
                         `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
                     ],
-                copyCommands: [],
+                copyCommands: !prebuiltBaseImage &&
+                    needsVendorCopyCommand([DAIMON_PACKAGE_NAME, MNEME_PACKAGE_NAME], packageOverrides)
+                    ? [createVendorCopyCommand()]
+                    : [],
+                env: containerEnv,
                 runtimeName,
                 runtimeRoot: installRoot
             };