spawnfile 0.1.11 → 0.1.13

package/dist/manifest/schemas.d.ts

@@ -258,27 +258,21 @@ declare const agentManifestSchema: z.ZodObject<{
         moltnet: z.ZodOptional<z.ZodArray<z.ZodObject<{
             dms: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodBoolean;
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>;
             network: z.ZodString;
             rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         slack: z.ZodOptional<z.ZodObject<{
@@ -536,27 +530,21 @@ declare const teamManifestSchema: z.ZodObject<{
         moltnet: z.ZodOptional<z.ZodArray<z.ZodObject<{
             dms: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodBoolean;
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>;
             network: z.ZodString;
             rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         slack: z.ZodOptional<z.ZodObject<{
@@ -942,27 +930,21 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         moltnet: z.ZodOptional<z.ZodArray<z.ZodObject<{
             dms: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodBoolean;
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>;
             network: z.ZodString;
             rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         slack: z.ZodOptional<z.ZodObject<{
@@ -1219,27 +1201,21 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         moltnet: z.ZodOptional<z.ZodArray<z.ZodObject<{
             dms: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodBoolean;
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>;
             network: z.ZodString;
             rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                read: z.ZodOptional<z.ZodEnum<{
+                wake: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
                     all: "all";
                     mentions: "mentions";
                     thread_only: "thread_only";
                 }>>;
-                reply: z.ZodOptional<z.ZodEnum<{
-                    never: "never";
-                    auto: "auto";
-                }>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>>;
         slack: z.ZodOptional<z.ZodObject<{
@@ -1540,6 +1516,6 @@ export type SkillReference = z.infer<typeof skillReferenceSchema>;
 export type TeamManifest = z.infer<typeof teamManifestSchema>;
 export type { ExecutionBlock, ModelEndpoint, ModelEntryAuth, ModelTarget } from "./executionSchemas.js";
 export type { TeamNetwork, TeamNetworkRoom, TeamNetworkServer, TeamWorkspace, TeamWorkspaceResource } from "./teamNetworkSchemas.js";
-export type { DiscordSurface, DiscordSurfaceAccess, HttpSurface, HttpSurfaceAccess, HttpSurfaceAuth, MoltnetAttachment, MoltnetDM, MoltnetRead, MoltnetReply, MoltnetRoomBehavior, MoltnetSurface, SlackSurface, SlackSurfaceAccess, SurfacesBlock, TelegramSurface, TelegramSurfaceAccess, WebhookSurface, WhatsAppSurface, WhatsAppSurfaceAccess } from "./surfaceSchemas.js";
+export type { DiscordSurface, DiscordSurfaceAccess, HttpSurface, HttpSurfaceAccess, HttpSurfaceAuth, MoltnetAttachment, MoltnetDM, MoltnetRoomBehavior, MoltnetSurface, MoltnetWake, SlackSurface, SlackSurfaceAccess, SurfacesBlock, TelegramSurface, TelegramSurfaceAccess, WebhookSurface, WhatsAppSurface, WhatsAppSurfaceAccess } from "./surfaceSchemas.js";
 export declare const isAgentManifest: (manifest: Manifest) => manifest is AgentManifest;
 export declare const isTeamManifest: (manifest: Manifest) => manifest is TeamManifest;

package/dist/manifest/surfaceSchemas.d.ts

@@ -102,88 +102,67 @@ declare const webhookSurfaceSchema: z.ZodObject<{
     signing_secret: z.ZodOptional<z.ZodString>;
     url: z.ZodString;
 }, z.core.$strict>;
-declare const moltnetReadSchema: z.ZodEnum<{
+declare const moltnetWakeSchema: z.ZodEnum<{
+    never: "never";
     all: "all";
     mentions: "mentions";
     thread_only: "thread_only";
 }>;
-declare const moltnetReplySchema: z.ZodEnum<{
-    never: "never";
-    auto: "auto";
-}>;
 declare const moltnetRoomBehaviorSchema: z.ZodObject<{
-    read: z.ZodOptional<z.ZodEnum<{
+    wake: z.ZodOptional<z.ZodEnum<{
+        never: "never";
         all: "all";
         mentions: "mentions";
         thread_only: "thread_only";
     }>>;
-    reply: z.ZodOptional<z.ZodEnum<{
-        never: "never";
-        auto: "auto";
-    }>>;
 }, z.core.$strict>;
 declare const moltnetDmSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
-    read: z.ZodOptional<z.ZodEnum<{
+    wake: z.ZodOptional<z.ZodEnum<{
+        never: "never";
         all: "all";
         mentions: "mentions";
         thread_only: "thread_only";
     }>>;
-    reply: z.ZodOptional<z.ZodEnum<{
-        never: "never";
-        auto: "auto";
-    }>>;
 }, z.core.$strict>;
 declare const moltnetAttachmentSchema: z.ZodObject<{
     dms: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
-        read: z.ZodOptional<z.ZodEnum<{
+        wake: z.ZodOptional<z.ZodEnum<{
+            never: "never";
             all: "all";
             mentions: "mentions";
             thread_only: "thread_only";
         }>>;
-        reply: z.ZodOptional<z.ZodEnum<{
-            never: "never";
-            auto: "auto";
-        }>>;
     }, z.core.$strict>>;
     network: z.ZodString;
     rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        read: z.ZodOptional<z.ZodEnum<{
+        wake: z.ZodOptional<z.ZodEnum<{
+            never: "never";
             all: "all";
             mentions: "mentions";
             thread_only: "thread_only";
         }>>;
-        reply: z.ZodOptional<z.ZodEnum<{
-            never: "never";
-            auto: "auto";
-        }>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 declare const moltnetSurfaceSchema: z.ZodArray<z.ZodObject<{
     dms: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodBoolean;
-        read: z.ZodOptional<z.ZodEnum<{
+        wake: z.ZodOptional<z.ZodEnum<{
+            never: "never";
             all: "all";
             mentions: "mentions";
             thread_only: "thread_only";
         }>>;
-        reply: z.ZodOptional<z.ZodEnum<{
-            never: "never";
-            auto: "auto";
-        }>>;
     }, z.core.$strict>>;
     network: z.ZodString;
     rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        read: z.ZodOptional<z.ZodEnum<{
+        wake: z.ZodOptional<z.ZodEnum<{
+            never: "never";
             all: "all";
             mentions: "mentions";
             thread_only: "thread_only";
         }>>;
-        reply: z.ZodOptional<z.ZodEnum<{
-            never: "never";
-            auto: "auto";
-        }>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>>;
 export declare const surfacesSchema: z.ZodObject<{
@@ -206,27 +185,21 @@ export declare const surfacesSchema: z.ZodObject<{
     moltnet: z.ZodOptional<z.ZodArray<z.ZodObject<{
         dms: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
-            read: z.ZodOptional<z.ZodEnum<{
+            wake: z.ZodOptional<z.ZodEnum<{
+                never: "never";
                 all: "all";
                 mentions: "mentions";
                 thread_only: "thread_only";
             }>>;
-            reply: z.ZodOptional<z.ZodEnum<{
-                never: "never";
-                auto: "auto";
-            }>>;
         }, z.core.$strict>>;
         network: z.ZodString;
         rooms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            read: z.ZodOptional<z.ZodEnum<{
+            wake: z.ZodOptional<z.ZodEnum<{
+                never: "never";
                 all: "all";
                 mentions: "mentions";
                 thread_only: "thread_only";
             }>>;
-            reply: z.ZodOptional<z.ZodEnum<{
-                never: "never";
-                auto: "auto";
-            }>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
     slack: z.ZodOptional<z.ZodObject<{
@@ -287,10 +260,9 @@ export type HttpSurfaceAuth = never;
 export type HttpSurface = never;
 export type MoltnetAttachment = z.infer<typeof moltnetAttachmentSchema>;
 export type MoltnetDM = z.infer<typeof moltnetDmSchema>;
-export type MoltnetRead = z.infer<typeof moltnetReadSchema>;
-export type MoltnetReply = z.infer<typeof moltnetReplySchema>;
 export type MoltnetRoomBehavior = z.infer<typeof moltnetRoomBehaviorSchema>;
 export type MoltnetSurface = z.infer<typeof moltnetSurfaceSchema>;
+export type MoltnetWake = z.infer<typeof moltnetWakeSchema>;
 export type SlackSurfaceAccess = z.infer<typeof slackSurfaceAccessSchema>;
 export type SlackSurface = z.infer<typeof slackSurfaceSchema>;
 export type TelegramSurfaceAccess = z.infer<typeof telegramSurfaceAccessSchema>;

package/dist/manifest/surfaceSchemas.js

@@ -178,19 +178,16 @@ const webhookSurfaceSchema = z
     url: z.string().url()
 })
     .strict();
-const moltnetReadSchema = z.enum(["all", "mentions", "thread_only"]);
-const moltnetReplySchema = z.enum(["auto", "never"]);
+const moltnetWakeSchema = z.enum(["all", "mentions", "thread_only", "never"]);
 const moltnetRoomBehaviorSchema = z
     .object({
-    read: moltnetReadSchema.optional(),
-    reply: moltnetReplySchema.optional()
+    wake: moltnetWakeSchema.optional()
 })
     .strict();
 const moltnetDmSchema = z
     .object({
     enabled: z.boolean(),
-    read: moltnetReadSchema.optional(),
-    reply: moltnetReplySchema.optional()
+    wake: moltnetWakeSchema.optional()
 })
     .strict();
 const moltnetAttachmentSchema = z

package/dist/report/createReport.d.ts

@@ -1,2 +1,8 @@
 import { CompileReport, ContainerReport, DiagnosticReport, NodeReport } from "./types.js";
-export declare const createCompileReport: (root: string, nodes: NodeReport[], diagnostics?: DiagnosticReport[], container?: ContainerReport) => CompileReport;
+export interface CreateCompileReportOptions {
+    compileFingerprint?: string;
+    generatedAt?: string;
+    outputDirectory?: string;
+    projectName?: string;
+}
+export declare const createCompileReport: (root: string, nodes: NodeReport[], diagnostics?: DiagnosticReport[], container?: ContainerReport, options?: CreateCompileReportOptions) => CompileReport;

package/dist/report/createReport.js

@@ -1,7 +1,34 @@
-export const createCompileReport = (root, nodes, diagnostics = [], container) => ({
+import { createHash } from "node:crypto";
+const stableStringify = (value) => {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+};
+const createCompileFingerprint = (root, nodes, diagnostics, container) => {
+    const payload = stableStringify({
+        container,
+        diagnostics,
+        nodes,
+        root,
+        spawnfile_version: "0.1"
+    });
+    return `sf1:${createHash("sha1").update(payload).digest("hex").slice(0, 12)}`;
+};
+export const createCompileReport = (root, nodes, diagnostics = [], container, options = {}) => ({
+    compile_fingerprint: options.compileFingerprint ?? createCompileFingerprint(root, nodes, diagnostics, container),
     ...(container ? { container } : {}),
     diagnostics,
+    generated_at: options.generatedAt ?? new Date().toISOString(),
     nodes,
+    ...(options.outputDirectory ? { output_directory: options.outputDirectory } : {}),
+    ...(options.projectName ? { project_name: options.projectName } : {}),
     root,
     spawnfile_version: "0.1"
 });

package/dist/report/types.d.ts

@@ -14,9 +14,13 @@ export interface ContainerRuntimeInstanceReport {
     config_path: string;
     home_path: string | null;
     id: string;
+    internal_port?: number | null;
     model_auth_methods: Record<string, ModelAuthMethod>;
     model_secrets_required: string[];
+    node_ids?: string[];
+    published_port?: number | null;
     runtime: string;
+    workspace_path?: string;
 }
 export interface ContainerWorkspaceResourceReport {
     backing_path: string;
@@ -33,6 +37,37 @@ export interface ContainerPersistentMountReport {
     reason: string;
     volume_name: string;
 }
+export interface ContainerPortMappingReport {
+    internal_port: number;
+    published_port: number;
+}
+export interface ContainerMoltnetNodePlanSummary {
+    config_path: string;
+    network_id: string;
+}
+export interface ContainerMoltnetServerPlanSummary {
+    auth_mode?: "bearer" | "none" | "open";
+    base_url: string;
+    config_path?: string;
+    direct_messages?: boolean;
+    id: string;
+    mode: "external" | "managed";
+    network_id: string;
+    operator_token_secret?: string;
+    port?: number;
+    public_read?: boolean;
+    rooms: Array<{
+        id: string;
+        members: string[];
+        visibility?: "public" | "private";
+        write_policy?: "members" | "operators" | "registered_agents";
+    }>;
+    store_kind?: "json" | "memory" | "postgres" | "sqlite";
+}
+export interface ContainerMoltnetPlanSummary {
+    node_plans: ContainerMoltnetNodePlanSummary[];
+    server_plans: ContainerMoltnetServerPlanSummary[];
+}
 export interface NodeReport {
     capabilities: CapabilityReport[];
     diagnostics: DiagnosticReport[];
@@ -48,8 +83,12 @@ export interface ContainerReport {
     dockerfile: string;
     entrypoint: string;
     env_example: string;
+    internal_ports?: number[];
     model_secrets_required: string[];
+    moltnet?: ContainerMoltnetPlanSummary;
+    port_mappings?: ContainerPortMappingReport[];
     ports: number[];
+    published_ports?: number[];
     runtime_instances: ContainerRuntimeInstanceReport[];
     runtime_homes: string[];
     runtime_secrets_required: string[];
@@ -59,9 +98,13 @@ export interface ContainerReport {
     workspace_resources?: ContainerWorkspaceResourceReport[];
 }
 export interface CompileReport {
+    compile_fingerprint?: string;
     container?: ContainerReport;
     diagnostics: DiagnosticReport[];
+    generated_at?: string;
     nodes: NodeReport[];
+    output_directory?: string;
+    project_name?: string;
     root: string;
     spawnfile_version: "0.1";
 }

package/dist/runtime/common.d.ts

@@ -7,6 +7,8 @@ export declare const createDocumentFiles: (baseDirectory: string, documents: Res
 export declare const createSkillFiles: (baseDirectory: string, skills: ResolvedSkill[]) => EmittedFile[];
 export declare const createAgentCapabilities: (node: ResolvedAgentNode, options?: {
     mcpOutcome?: CapabilityReport["outcome"];
+    moltnetMessage?: string;
+    moltnetOutcome?: CapabilityReport["outcome"];
     sandboxOutcome?: CapabilityReport["outcome"];
     scheduleMessage?: string;
     scheduleOutcome?: CapabilityReport["outcome"];

package/dist/runtime/common.js

@@ -48,7 +48,7 @@ export const createAgentCapabilities = (node, options = {}) => {
         capabilities.push(createCapability("surfaces.discord", "supported"));
     }
     if (node.surfaces?.moltnet) {
-        capabilities.push(createCapability("surfaces.moltnet", "supported"));
+        capabilities.push(createCapability("surfaces.moltnet", options.moltnetOutcome ?? "supported", options.moltnetMessage));
     }
     if (node.surfaces?.telegram) {
         capabilities.push(createCapability("surfaces.telegram", "supported"));

package/dist/runtime/container.d.ts

@@ -1,5 +1,6 @@
 export declare const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
 export interface RuntimeInstallRecipe {
+    baseImage?: string;
     commands: string[];
     copyCommands: string[];
     runtimeName: string;

package/dist/runtime/container.js

@@ -1,7 +1,14 @@
 import { SpawnfileError } from "../shared/index.js";
 import { resolveRuntimeInstallSelection } from "./install.js";
 export const RUNTIME_INSTALL_ROOT = "/opt/spawnfile/runtime-installs";
-const createGitHubReleaseUrl = (repository, tag, asset) => `https://github.com/${repository}/releases/download/${tag}/${asset}`;
+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 OPENCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_OPENCLAW_RUNTIME_IMAGE";
+const PICOCLAW_RUNTIME_IMAGE_ENV = "SPAWNFILE_PICOCLAW_RUNTIME_IMAGE";
+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 assertArtifactInstallSelection = (runtimeName, selection) => {
     if (selection.kind !== "source_repo") {
         return;
@@ -12,29 +19,50 @@ const createPicoClawArchiveInstallCommands = (runtimeRoot, selection) => [
     `mkdir -p ${runtimeRoot}/bin`,
     `arch="$(dpkg --print-architecture)" && case "$arch" in amd64) asset=${JSON.stringify(selection.versionedAssets.linux_amd64)} ;; arm64) asset=${JSON.stringify(selection.versionedAssets.linux_arm64)} ;; *) echo "Unsupported PicoClaw release architecture: $arch" >&2; exit 1 ;; esac && url="https://github.com/${selection.repository}/releases/download/${selection.tag}/$asset" && curl -fsSL -o /tmp/picoclaw.tar.gz "$url" && rm -rf /tmp/picoclaw-extract && mkdir -p /tmp/picoclaw-extract && tar -xzf /tmp/picoclaw.tar.gz -C /tmp/picoclaw-extract && binary_path="$(find /tmp/picoclaw-extract -type f -name ${JSON.stringify(selection.binaryName)} | head -n 1)" && [ -n "$binary_path" ] && install -m 0755 "$binary_path" ${runtimeRoot}/bin/${selection.binaryName} && ln -sf ${runtimeRoot}/bin/${selection.binaryName} /usr/local/bin/${selection.binaryName} && rm -rf /tmp/picoclaw.tar.gz /tmp/picoclaw-extract`
 ];
+const createRuntimeImageCopyCommand = (imageRef, runtimeRoot) => `COPY --from=${imageRef} ${runtimeRoot} ${runtimeRoot}`;
+const resolveRuntimeImageRef = (envName, selection) => process.env[envName]?.trim() ||
+    (selection.kind === "container_image"
+        ? `${selection.image}:${selection.tag}`
+        : undefined);
 export const createRuntimeInstallRecipe = async (runtimeName) => {
     const selection = await resolveRuntimeInstallSelection(runtimeName);
     assertArtifactInstallSelection(runtimeName, selection);
     const installRoot = `${RUNTIME_INSTALL_ROOT}/${runtimeName}`;
     switch (runtimeName) {
         case "openclaw": {
-            if (selection.kind !== "container_image" && selection.kind !== "npm") {
+            const openClawRuntimeImage = resolveRuntimeImageRef(OPENCLAW_RUNTIME_IMAGE_ENV, selection);
+            if (openClawRuntimeImage) {
+                return {
+                    commands: [],
+                    copyCommands: [createRuntimeImageCopyCommand(openClawRuntimeImage, installRoot)],
+                    runtimeName,
+                    runtimeRoot: installRoot
+                };
+            }
+            if (selection.kind !== "npm") {
                 throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
             }
             return {
-                commands: selection.kind === "container_image"
-                    ? []
-                    : [`npm install -g --omit=dev --no-fund --no-audit ${selection.packageName}@${selection.version}`],
-                copyCommands: selection.kind === "container_image"
-                    ? [`COPY --from=${selection.image}:${selection.tag} /app ${installRoot}`]
-                    : [],
+                commands: [
+                    `npm install -g --omit=dev --no-fund --no-audit ${selection.packageName}@${selection.version}`
+                ],
+                copyCommands: [],
                 runtimeName,
-                runtimeRoot: selection.kind === "container_image"
-                    ? installRoot
-                    : `/usr/local/lib/node_modules/${selection.packageName}`
+                runtimeRoot: `/usr/local/lib/node_modules/${selection.packageName}`
             };
         }
         case "picoclaw": {
+            const picoClawRuntimeImage = resolveRuntimeImageRef(PICOCLAW_RUNTIME_IMAGE_ENV, selection);
+            if (picoClawRuntimeImage) {
+                return {
+                    commands: [
+                        `mkdir -p /usr/local/bin && ln -sf ${installRoot}/bin/picoclaw /usr/local/bin/picoclaw`
+                    ],
+                    copyCommands: [createRuntimeImageCopyCommand(picoClawRuntimeImage, installRoot)],
+                    runtimeName,
+                    runtimeRoot: installRoot
+                };
+            }
             if (selection.kind !== "github_release_archive") {
                 throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
             }
@@ -45,21 +73,60 @@ export const createRuntimeInstallRecipe = async (runtimeName) => {
                 runtimeRoot: installRoot
             };
         }
-        case "tinyclaw": {
-            if (selection.kind !== "github_release_bundle") {
+        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}`
+            ];
             return {
                 commands: [
                     `mkdir -p ${installRoot}`,
-                    `curl -fsSL ${JSON.stringify(createGitHubReleaseUrl(selection.repository, selection.tag, selection.asset))} | tar -xz --strip-components=1 -C ${installRoot}`,
-                    `cd ${installRoot} && npm rebuild better-sqlite3 --silent`
+                    `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
                 ],
                 copyCommands: [],
                 runtimeName,
                 runtimeRoot: installRoot
             };
         }
+        case "pi": {
+            if (selection.kind !== "npm") {
+                throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no compiled artifact recipe for ${selection.kind}`);
+            }
+            const prebuiltBaseImage = process.env[PI_RUNTIME_BASE_IMAGE_ENV]?.trim() || undefined;
+            const npmPackages = [
+                `${selection.packageName}@${selection.version}`,
+                `${PI_AI_PACKAGE_NAME}@${selection.version}`
+            ];
+            return {
+                ...(prebuiltBaseImage ? { baseImage: prebuiltBaseImage } : {}),
+                commands: prebuiltBaseImage
+                    ? [`mkdir -p ${installRoot}`]
+                    : [
+                        `mkdir -p ${installRoot}`,
+                        `cd ${installRoot} && npm install --omit=dev --no-fund --no-audit ${npmPackages.join(" ")}`
+                    ],
+                copyCommands: [],
+                runtimeName,
+                runtimeRoot: installRoot
+            };
+        }
         /* c8 ignore next 5 -- compileable runtimes are exhaustively covered above */
         default:
             throw new SpawnfileError("runtime_error", `Runtime ${runtimeName} has no container install recipe`);

package/dist/runtime/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./container.js";
 export * from "./install.js";
 export * from "./registry.js";
+export * from "./statusProbes.js";
 export * from "./types.js";

package/dist/runtime/index.js

@@ -1,4 +1,5 @@
 export * from "./container.js";
 export * from "./install.js";
 export * from "./registry.js";
+export * from "./statusProbes.js";
 export * from "./types.js";

package/dist/runtime/install.d.ts

@@ -1,5 +1,5 @@
 export type RuntimeInstallSelection = {
-    ecosystem: "node";
+    ecosystem: "go" | "node";
     image: string;
     installHint: string;
     kind: "container_image";
@@ -18,16 +18,6 @@ export type RuntimeInstallSelection = {
     selectionSource: "runtime_registry_install";
     tag: string;
     versionedAssets: Record<string, string>;
-} | {
-    asset: string;
-    ecosystem: "node";
-    installHint: string;
-    kind: "github_release_bundle";
-    repository: string;
-    runtimeName: string;
-    runtimeRef: string;
-    selectionSource: "runtime_registry_install";
-    tag: string;
 } | {
     ecosystem: "node";
     installHint: string;