spawnfile 0.1.14 → 0.1.17

package/dist/manifest/schemas.js

@@ -5,7 +5,7 @@ import { memoryBanksSchema } from "./memorySchemas.js";
 import { mcpServerSchema } from "./mcpSchemas.js";
 import { surfacesSchema } from "./surfaceSchemas.js";
 import { externalParticipantServiceSchema } from "./externalParticipantSchemas.js";
-import { teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
+import { isDeclaredPairedRemoteRoomMember, teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
 const skillRequirementSchema = z
     .object({
     mcp: z.array(z.string()).optional()
@@ -217,7 +217,9 @@ const teamManifestSchema = commonManifestSchema
                 .map((participant) => participant.id) ?? []);
             for (const room of network.rooms) {
                 for (const memberId of room.members) {
-                    if (!memberIds.has(memberId) && !externalRoomMembers.has(memberId)) {
+                    if (!memberIds.has(memberId)
+                        && !externalRoomMembers.has(memberId)
+                        && !isDeclaredPairedRemoteRoomMember(network, room, memberId)) {
                         context.addIssue({
                             code: z.ZodIssueCode.custom,
                             message: `network ${network.id} room ${room.id} references unknown member ${memberId}`
@@ -256,6 +258,7 @@ export const manifestSchema = z.discriminatedUnion("kind", [
     agentManifestSchema,
     teamManifestSchema
 ]);
+export { isDeclaredPairedRemoteRoomMember } from "./teamNetworkSchemas.js";
 export const isAgentManifest = (manifest) => manifest.kind === "agent";
 export const isTeamManifest = (manifest) => manifest.kind === "team";
 export const isInlineAgentMember = (member) => !("ref" in member);

package/dist/manifest/teamNetworkAccessSchemas.d.ts

@@ -1,9 +1,13 @@
 import { z } from "zod";
 export declare const teamNetworkAgentRegistrationSchema: z.ZodEnum<{
-    token: "token";
     disabled: "disabled";
+    token: "token";
     open: "open";
 }>;
+export declare const teamNetworkRoomFederationSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    none: "none";
+    all: "all";
+}>, z.ZodArray<z.ZodString>]>;
 export declare const teamNetworkRoomVisibilitySchema: z.ZodEnum<{
     private: "private";
     public: "public";

package/dist/manifest/teamNetworkAccessSchemas.js

@@ -1,5 +1,16 @@
 import { z } from "zod";
 export const teamNetworkAgentRegistrationSchema = z.enum(["disabled", "token", "open"]);
+export const teamNetworkRoomFederationSchema = z.union([
+    z.enum(["none", "all"]),
+    z.array(z.string().trim().min(1)).min(1).superRefine((value, context) => {
+        if (new Set(value).size !== value.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "room federation pairing ids must be unique"
+            });
+        }
+    })
+]);
 export const teamNetworkRoomVisibilitySchema = z.enum(["public", "private"]);
 export const teamNetworkRoomWritePolicySchema = z.enum([
     "members",

package/dist/manifest/teamNetworkAuthSchemas.d.ts

@@ -15,8 +15,8 @@ declare const teamNetworkAuthTokenSchema: z.ZodObject<{
 export declare const isTopologyOperatorToken: (token: z.infer<typeof teamNetworkAuthTokenSchema>) => boolean;
 export declare const teamNetworkAuthSchema: z.ZodObject<{
     agent_registration: z.ZodOptional<z.ZodEnum<{
-        token: "token";
         disabled: "disabled";
+        token: "token";
         open: "open";
     }>>;
     client: z.ZodOptional<z.ZodObject<{

package/dist/manifest/teamNetworkSchemas.d.ts

@@ -4,6 +4,10 @@ export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorks
 export type { TeamNetworkAuth } from "./teamNetworkAuthSchemas.js";
 export type { TeamNetworkServer, TeamNetworkStore } from "./teamNetworkServerSchemas.js";
 declare const teamNetworkRoomSchema: z.ZodObject<{
+    federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        none: "none";
+        all: "all";
+    }>, z.ZodArray<z.ZodString>]>>;
     id: z.ZodString;
     members: z.ZodArray<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
@@ -22,6 +26,10 @@ export declare const teamNetworkSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     provider: z.ZodLiteral<"moltnet">;
     rooms: z.ZodArray<z.ZodObject<{
+        federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            none: "none";
+            all: "all";
+        }>, z.ZodArray<z.ZodString>]>>;
         id: z.ZodString;
         members: z.ZodArray<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
@@ -39,8 +47,8 @@ export declare const teamNetworkSchema: z.ZodObject<{
         allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
         auth: z.ZodObject<{
             agent_registration: z.ZodOptional<z.ZodEnum<{
-                token: "token";
                 disabled: "disabled";
+                token: "token";
                 open: "open";
             }>>;
             client: z.ZodOptional<z.ZodObject<{
@@ -84,7 +92,12 @@ export declare const teamNetworkSchema: z.ZodObject<{
         mode: z.ZodLiteral<"managed">;
         pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
-            remote_base_url: z.ZodString;
+            relay: z.ZodOptional<z.ZodObject<{
+                room: z.ZodString;
+                token_secret: z.ZodString;
+                url: z.ZodString;
+            }, z.core.$strict>>;
+            remote_base_url: z.ZodOptional<z.ZodString>;
             remote_network_id: z.ZodString;
             remote_network_name: z.ZodString;
             token_secret: z.ZodString;
@@ -122,8 +135,8 @@ export declare const teamNetworkSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         auth: z.ZodObject<{
             agent_registration: z.ZodOptional<z.ZodEnum<{
-                token: "token";
                 disabled: "disabled";
+                token: "token";
                 open: "open";
             }>>;
             client: z.ZodOptional<z.ZodObject<{
@@ -157,3 +170,4 @@ export declare const teamNetworkSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type TeamNetwork = z.infer<typeof teamNetworkSchema>;
 export type TeamNetworkRoom = z.infer<typeof teamNetworkRoomSchema>;
+export declare const isDeclaredPairedRemoteRoomMember: (network: TeamNetwork, room: TeamNetworkRoom, memberId: string) => boolean;

package/dist/manifest/teamNetworkSchemas.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { teamNetworkRoomVisibilitySchema, teamNetworkRoomWritePolicySchema } from "./teamNetworkAccessSchemas.js";
+import { teamNetworkRoomFederationSchema, teamNetworkRoomVisibilitySchema, teamNetworkRoomWritePolicySchema } from "./teamNetworkAccessSchemas.js";
 import { teamNetworkServerSchema } from "./teamNetworkServerSchemas.js";
 export { teamWorkspaceDocsSchema, teamWorkspaceSchema } from "./workspaceSchemas.js";
 const teamNetworkRoomSchema = z
     .object({
+    federation: teamNetworkRoomFederationSchema.optional(),
     id: z.string().trim().min(1),
     members: z.array(z.string().trim().min(1)),
     name: z.string().trim().min(1).optional(),
@@ -29,3 +30,20 @@ export const teamNetworkSchema = z
         });
     }
 });
+export const isDeclaredPairedRemoteRoomMember = (network, room, memberId) => {
+    const separator = memberId.indexOf(":");
+    if (separator <= 0 || separator === memberId.length - 1) {
+        return false;
+    }
+    const remoteNetworkId = memberId.slice(0, separator).trim();
+    const remoteAgentId = memberId.slice(separator + 1).trim();
+    if (!remoteNetworkId || !remoteAgentId || network.server?.mode !== "managed") {
+        return false;
+    }
+    const pairing = network.server.pairings?.find((candidate) => candidate.remote_network_id === remoteNetworkId);
+    if (!pairing) {
+        return false;
+    }
+    return room.federation === "all"
+        || (Array.isArray(room.federation) && room.federation.includes(pairing.id));
+};

package/dist/manifest/teamNetworkServerSchemas.d.ts

@@ -31,8 +31,8 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     auth: z.ZodObject<{
         agent_registration: z.ZodOptional<z.ZodEnum<{
-            token: "token";
             disabled: "disabled";
+            token: "token";
             open: "open";
         }>>;
         client: z.ZodOptional<z.ZodObject<{
@@ -76,7 +76,12 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     mode: z.ZodLiteral<"managed">;
     pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        remote_base_url: z.ZodString;
+        relay: z.ZodOptional<z.ZodObject<{
+            room: z.ZodString;
+            token_secret: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>;
+        remote_base_url: z.ZodOptional<z.ZodString>;
         remote_network_id: z.ZodString;
         remote_network_name: z.ZodString;
         token_secret: z.ZodString;
@@ -114,8 +119,8 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
 }, z.core.$strict>, z.ZodObject<{
     auth: z.ZodObject<{
         agent_registration: z.ZodOptional<z.ZodEnum<{
-            token: "token";
             disabled: "disabled";
+            token: "token";
             open: "open";
         }>>;
         client: z.ZodOptional<z.ZodObject<{

package/dist/manifest/teamNetworkServerSchemas.js

@@ -68,15 +68,31 @@ const teamNetworkListenSchema = z
     port: z.number().int().min(1).max(65535)
 })
     .strict();
+const teamNetworkPairingRelaySchema = z
+    .object({
+    room: z.string().trim().min(1),
+    token_secret: z.string().trim().min(1),
+    url: z.string().trim().min(1)
+})
+    .strict();
 const teamNetworkPairingSchema = z
     .object({
     id: z.string().trim().min(1),
-    remote_base_url: z.string().trim().min(1),
+    relay: teamNetworkPairingRelaySchema.optional(),
+    remote_base_url: z.string().trim().min(1).optional(),
     remote_network_id: z.string().trim().min(1),
     remote_network_name: z.string().trim().min(1),
     token_secret: z.string().trim().min(1)
 })
-    .strict();
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.remote_base_url === undefined) === (value.relay === undefined)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "managed Moltnet pairing requires exactly one of remote_base_url or relay"
+        });
+    }
+});
 const teamNetworkManagedServerSchema = z
     .object({
     allowed_origins: z.array(z.string().trim().min(1)).optional(),

package/dist/manifest/workspaceSchemas.d.ts

@@ -23,6 +23,14 @@ declare const teamWorkspaceResourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     }>>;
     tag: z.ZodOptional<z.ZodString>;
     url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"bundle">;
+    mount: z.ZodString;
+    mode: z.ZodLiteral<"readonly">;
+    sha256: z.ZodString;
+    sharing: z.ZodOptional<z.ZodLiteral<"per_agent">>;
+    source: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodLiteral<"volume">;
@@ -68,6 +76,14 @@ export declare const teamWorkspaceSchema: z.ZodObject<{
         }>>;
         tag: z.ZodOptional<z.ZodString>;
         url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"bundle">;
+        mount: z.ZodString;
+        mode: z.ZodLiteral<"readonly">;
+        sha256: z.ZodString;
+        sharing: z.ZodOptional<z.ZodLiteral<"per_agent">>;
+        source: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         kind: z.ZodLiteral<"volume">;

package/dist/manifest/workspaceSchemas.js

@@ -89,8 +89,14 @@ const teamWorkspaceResourceVolumeSchema = z
     sharing: workspaceResourceSharingSchema.optional()
 })
     .strict();
+const teamWorkspaceResourceBundleSchema = z.object({
+    id: z.string().trim().min(1), kind: z.literal("bundle"), mount: resourceMountSchema,
+    mode: z.literal("readonly"), sha256: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    sharing: z.literal("per_agent").optional(), source: z.string().trim().min(1)
+}).strict();
 const teamWorkspaceResourceSchema = z.discriminatedUnion("kind", [
     teamWorkspaceResourceGitSchema,
+    teamWorkspaceResourceBundleSchema,
     teamWorkspaceResourceVolumeSchema
 ]);
 const workspaceSkillRequirementSchema = z
@@ -129,6 +135,11 @@ export const teamWorkspaceSchema = z
                 url: resource.url
             });
         }
+        if (resource.kind === "bundle")
+            return JSON.stringify({
+                kind: resource.kind, mode: resource.mode, mount: normalizeMount(resource.mount),
+                sha256: resource.sha256, sharing: resource.sharing ?? "per_agent", source: resource.source
+            });
         return JSON.stringify({
             kind: "volume",
             mode: resource.mode,

package/dist/report/types.d.ts

@@ -35,14 +35,32 @@ export interface ContainerRuntimeInstanceReport {
 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;
@@ -200,9 +218,16 @@ export interface ContainerMoltnetPlanSummary {
         architecture: "amd64" | "arm64";
         asset: string;
         asset_sha256: `sha256:${string}`;
-        capabilities: readonly ["pi-bridge"];
-        release_version: string;
-        source_revision: 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[];
@@ -224,6 +249,11 @@ 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[];

package/dist/runtime/common.d.ts

@@ -37,7 +37,34 @@ 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;

package/dist/runtime/common.js

@@ -62,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) {

package/dist/runtime/container.js

@@ -2,14 +2,18 @@ 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 DAIMON_PACKAGE_VERSION = "0.1.2";
+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";
@@ -40,6 +44,34 @@ const resolveRuntimeImageRef = (envName, selection) => process.env[envName]?.tri
     (selection.kind === "container_image"
         ? `${selection.image}:${selection.tag}`
         : undefined);
+/**
+ * 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);
@@ -96,38 +128,22 @@ export const createRuntimeInstallRecipe = async (runtimeName, options = {}) => {
             };
         }
         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)],
-                    env: containerEnv,
-                    runtimeName,
-                    runtimeRoot: installRoot
-                };
-            }
-            if (selection.kind !== "npm") {
-                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
-            }
-            const npmPackages = [
-                resolveInstallPackageSpec(selection.packageName, selection.version, packageOverrides),
-                resolveInstallPackageSpec(MNEME_PACKAGE_NAME, MNEME_PACKAGE_VERSION, packageOverrides),
-                `${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: needsVendorCopyCommand([selection.packageName, MNEME_PACKAGE_NAME], packageOverrides)
-                    ? [createVendorCopyCommand()]
-                    : [],
-                env: containerEnv,
+                copyCommands: [createRuntimeImageCopyCommand(daimonRuntime.image, installRoot)],
+                env: {
+                    ...containerEnv,
+                    [DAIMON_WAKE_FUSE_DIRECTORY_ENV]: DAIMON_WAKE_FUSE_DIRECTORY
+                },
                 runtimeName,
                 runtimeRoot: installRoot
             };
@@ -138,7 +154,7 @@ export const createRuntimeInstallRecipe = async (runtimeName, options = {}) => {
             }
             const prebuiltBaseImage = process.env[PI_RUNTIME_BASE_IMAGE_ENV]?.trim() || undefined;
             const npmPackages = [
-                resolveInstallPackageSpec(DAIMON_PACKAGE_NAME, DAIMON_PACKAGE_VERSION, packageOverrides),
+                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}`

package/dist/runtime/daimon/adapter.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { RuntimeAdapter } from "../types.js";
+/**
+ * Workspace skill roots per Daimon engine.
+ *
+ * Codex and AGY keep both CLI-engine roots. A brokered Grok worker loads no
+ * workspace skill at all: Grok 1.0.34 discovers `.agents/skills` (never
+ * `.codex/skills`) only in a trusted folder, and Daimon keeps the workspace
+ * untrusted (root-owned empty `trusted_folders.toml`) and replaces the system
+ * prompt, whose fixed text references no skill. Emitting either root would ship
+ * files nothing reads, so none are emitted and the declaration is reported.
+ */
+export declare const daimonSkillBaseDirectories: (node: ResolvedAgentNode) => readonly string[];
+export declare const daimonAdapter: RuntimeAdapter;