spawnfile 0.1.12 → 0.1.14

package/dist/runtime/picoclaw/adapter.js

@@ -3,10 +3,12 @@ import { SpawnfileError } from "../../shared/index.js";
 import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
 import { preparePicoClawRuntimeAuth } from "./runAuth.js";
 import { createPicoClawAgentScaffold } from "./scaffold.js";
-import { createPicoClawCronStoreFile, createScheduleDiagnostics, scheduleOutcomeFor } from "./schedules.js";
+import { createPicoClawCronStoreFile, createScheduleDiagnostics, hasPicoClawCronJobs, scheduleOutcomeFor } from "./schedules.js";
 import { assertSupportedPicoClawSurfaces, buildPicoClawChannelConfig, buildPicoClawSurfaceEnvBindings } from "./surfaces.js";
 import { PICOCLAW_GATEWAY_BASE_PORT, PICOCLAW_INTERNAL_PICO_TOKEN } from "./pico.js";
 import { picoClawStatusProbes } from "./statusProbes.js";
+import { buildPicoClawMemoryMcpServers, picoClawMemoryCapabilityFor, PICOCLAW_MNEME_PACKAGE } from "./memory.js";
+import { buildPicoClawAuthoredMcpServers, buildPicoClawMcpEnvBindings } from "./mcp.js";
 const formatModelName = (node) => {
     const primary = node.execution?.model?.primary;
     if (!primary)
@@ -75,31 +77,9 @@ const buildModelList = (node) => {
         };
     });
 };
-const buildMcpServers = (servers) => {
-    const result = {};
-    for (const server of servers) {
-        const entry = { enabled: true };
-        if (server.transport === "stdio") {
-            entry.command = server.command;
-            if (server.args)
-                entry.args = server.args;
-            if (server.env)
-                entry.env = server.env;
-        }
-        else {
-            entry.type = server.transport === "streamable_http" ? "http" : server.transport;
-            entry.url = server.url;
-        }
-        if (server.auth) {
-            entry.headers = { [server.auth.secret]: "" };
-        }
-        result[server.name] = entry;
-    }
-    return result;
-};
 const buildPicoClawToolsConfig = (node) => {
     const tools = {};
-    if (node.schedule?.kind === "cron") {
+    if (hasPicoClawCronJobs(node)) {
         tools.cron = {
             enabled: true
         };
@@ -112,7 +92,17 @@ const buildPicoClawToolsConfig = (node) => {
     if (node.mcpServers.length > 0) {
         tools.mcp = {
             enabled: true,
-            servers: buildMcpServers(node.mcpServers)
+            servers: buildPicoClawAuthoredMcpServers(node.mcpServers)
+        };
+    }
+    const memoryMcpServers = buildPicoClawMemoryMcpServers(node);
+    if (Object.keys(memoryMcpServers).length > 0) {
+        tools.mcp = {
+            enabled: true,
+            servers: {
+                ...(tools.mcp?.servers ?? {}),
+                ...memoryMcpServers
+            }
         };
     }
     return Object.keys(tools).length > 0 ? tools : undefined;
@@ -148,7 +138,10 @@ const createContainerTargets = async (inputs) => inputs.map((input) => {
         envName: secretName,
         relativePath: createSecretPath(secretName)
     }));
-    const configEnvBindings = buildPicoClawSurfaceEnvBindings(agent.surfaces);
+    const configEnvBindings = [
+        ...(buildPicoClawSurfaceEnvBindings(agent.surfaces) ?? []),
+        ...buildPicoClawMcpEnvBindings(agent.mcpServers)
+    ];
     return {
         configEnvBindings,
         envFiles,
@@ -190,7 +183,7 @@ export const picoClawAdapter = {
     container: {
         configFileName: "config.json",
         configPathEnv: "PICOCLAW_CONFIG",
-        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex"],
+        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex", PICOCLAW_MNEME_PACKAGE],
         homeEnv: "PICOCLAW_HOME",
         instancePaths: {
             configPathTemplate: "<instance-root>/picoclaw/<config-file>",
@@ -216,8 +209,11 @@ export const picoClawAdapter = {
     async compileAgent(node) {
         const scheduleOutcome = scheduleOutcomeFor(node);
         const cronStoreFile = createPicoClawCronStoreFile(node);
+        const memoryCapability = picoClawMemoryCapabilityFor(node);
         return {
             capabilities: createAgentCapabilities(node, {
+                memoryMessage: memoryCapability.message,
+                memoryOutcome: memoryCapability.outcome,
                 scheduleMessage: scheduleOutcome.message,
                 scheduleOutcome: scheduleOutcome.outcome
             }),

package/dist/runtime/picoclaw/mcp.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "../../manifest/index.js";
+import type { RuntimeContainerConfigEnvBinding } from "../types.js";
+export declare const buildPicoClawAuthoredMcpServers: (servers: McpServer[]) => Record<string, Record<string, unknown>>;
+export declare const buildPicoClawMcpEnvBindings: (servers: McpServer[]) => RuntimeContainerConfigEnvBinding[];

package/dist/runtime/picoclaw/mcp.js

@@ -0,0 +1,43 @@
+export const buildPicoClawAuthoredMcpServers = (servers) => {
+    const result = Object.create(null);
+    for (const server of servers) {
+        if (server.transport === "stdio" && server.auth?.mode === "bearer") {
+            throw new Error("PicoClaw stdio MCP servers do not support bearer auth");
+        }
+        const entry = { enabled: true };
+        if (server.transport === "stdio") {
+            entry.command = server.command;
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+        }
+        else {
+            entry.type = server.transport === "streamable_http" ? "http" : server.transport;
+            entry.url = server.url;
+        }
+        if (server.auth) {
+            entry.headers = {
+                [server.auth.mode === "bearer" ? "Authorization" : server.auth.secret]: ""
+            };
+        }
+        result[server.name] = entry;
+    }
+    return result;
+};
+export const buildPicoClawMcpEnvBindings = (servers) => servers.flatMap((server) => server.auth
+    ? [
+        {
+            envName: server.auth.secret,
+            jsonPath: [
+                "tools",
+                "mcp",
+                "servers",
+                server.name,
+                "headers",
+                server.auth.mode === "bearer" ? "Authorization" : server.auth.secret
+            ],
+            ...(server.auth.mode === "bearer" ? { transform: "bearer" } : {})
+        }
+    ]
+    : []);

package/dist/runtime/picoclaw/memory.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+export declare const buildPicoClawMemoryMcpServers: (node: ResolvedAgentNode) => Record<string, Record<string, unknown>>;
+export declare const picoClawMemoryCapabilityFor: (node: ResolvedAgentNode) => {
+    message: string;
+    outcome: "degraded" | "supported";
+};
+export declare const PICOCLAW_MNEME_PACKAGE = "@noopolis/mneme@0.1.1";

package/dist/runtime/picoclaw/memory.js

@@ -0,0 +1,17 @@
+import { buildMnemeMemoryMcpServers, hasScheduledMemoryConsolidation, hasUnsupportedMnemeMemoryAccess, MNEME_PACKAGE } from "../mnemeMcp.js";
+export const buildPicoClawMemoryMcpServers = (node) => buildMnemeMemoryMcpServers(node, {
+    modes: hasScheduledMemoryConsolidation(node) ? ["awake", "dream"] : ["awake"]
+});
+export const picoClawMemoryCapabilityFor = (node) => {
+    if (hasUnsupportedMnemeMemoryAccess(node)) {
+        return {
+            message: "PicoClaw lowers file-backed Mneme memory through generated MCP servers; non-file stores are not lowered",
+            outcome: "degraded"
+        };
+    }
+    return {
+        message: "PicoClaw accesses Mneme memory through generated MCP servers",
+        outcome: "supported"
+    };
+};
+export const PICOCLAW_MNEME_PACKAGE = MNEME_PACKAGE;

package/dist/runtime/picoclaw/runAuth.js

@@ -10,7 +10,7 @@ export const preparePicoClawRuntimeAuth = async (input) => {
     if (!input.instance.home_path) {
         return { coveredModelSecrets: [], mountArgs: [] };
     }
-    const claudeCode = input.authProfile.imports["claude-code"]
+    const claudeCode = input.authProfile?.imports["claude-code"]
         ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
         : null;
     const useClaudeCode = input.instance.model_auth_methods.anthropic === "claude-code" && claudeCode;

package/dist/runtime/picoclaw/scaffold.js

@@ -11,7 +11,7 @@ export const createPicoClawAgentScaffold = () => ({
             path: "SOUL.md"
         },
         {
-            content: loadRuntimeScaffoldAsset(import.meta.url, "AGENTS.md"),
+            content: loadRuntimeScaffoldAsset(import.meta.url, "WORKSPACE_AGENTS.md"),
             path: "AGENTS.md"
         }
     ],

package/dist/runtime/picoclaw/schedules.d.ts

@@ -1,9 +1,35 @@
 import type { ResolvedAgentNode } from "../../compiler/types.js";
 import type { CapabilityReport } from "../../report/index.js";
 import type { EmittedFile } from "../types.js";
+type PicoClawCronSchedule = {
+    expr?: string;
+    kind: "cron";
+    tz?: string;
+} | {
+    everyMs: number;
+    kind: "every";
+};
+interface PicoClawCronJob {
+    createdAtMs: number;
+    deleteAfterRun: boolean;
+    enabled: boolean;
+    id: string;
+    name: string;
+    payload: {
+        deliver: boolean;
+        kind: "agent_turn";
+        message: string;
+    };
+    schedule: PicoClawCronSchedule;
+    state: Record<string, never>;
+    updatedAtMs: number;
+}
+export declare const createPicoClawCronJobs: (node: ResolvedAgentNode) => PicoClawCronJob[];
 export declare const createPicoClawCronStoreFile: (node: ResolvedAgentNode) => EmittedFile | null;
+export declare const hasPicoClawCronJobs: (node: ResolvedAgentNode) => boolean;
 export declare const scheduleOutcomeFor: (node: ResolvedAgentNode) => {
     message?: string;
     outcome?: CapabilityReport["outcome"];
 };
 export declare const createScheduleDiagnostics: (node: ResolvedAgentNode) => import("../../report/types.js").DiagnosticReport[];
+export {};

package/dist/runtime/picoclaw/schedules.js

@@ -1,4 +1,7 @@
+import { slugify } from "../../compiler/helpers.js";
 import { createDiagnostic } from "../common.js";
+import { isMnemeMemoryAccessSupported, mnemeMemoryServerName } from "../mnemeMcp.js";
+import { parseEveryScheduleMs } from "../scheduleUtils.js";
 const createPicoClawCronJob = (node) => {
     if (!node.schedule || node.schedule.kind !== "cron") {
         return null;
@@ -23,13 +26,68 @@ const createPicoClawCronJob = (node) => {
         updatedAtMs: 0
     };
 };
+const dreamPrompt = (bankId, serverName) => [
+    `Dream over Mneme memory bank ${bankId}.`,
+    "This is an isolated memory-maintenance session, not normal conversation.",
+    `Prefer the ${serverName} MCP tools when available.`,
+    "Search the active dream scope and read-only global scope for stale, duplicate, noisy, or important memories.",
+    "Use memory_summarize, memory_register, or memory_forget only when consolidation is evidence-backed."
+].join(" ");
+const scheduleFromMemoryConsolidation = (schedule) => {
+    const everyMs = parseEveryScheduleMs(schedule);
+    if (everyMs !== null) {
+        return { everyMs, kind: "every" };
+    }
+    return { expr: schedule, kind: "cron" };
+};
+const createPicoClawMemoryDreamJobs = (node) => {
+    const jobs = [];
+    const seen = new Set();
+    for (const access of node.memoryAccess ?? []) {
+        const schedule = access.bank.consolidation.schedule;
+        if (!isMnemeMemoryAccessSupported(access) ||
+            access.bank.consolidation.mode !== "scheduled" ||
+            !schedule) {
+            continue;
+        }
+        const key = `${access.source}:${access.bank.id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        const dreamServerName = mnemeMemoryServerName(node, access, "dream");
+        const bankSlug = dreamServerName.replace(/^mneme-/u, "").replace(/-dream$/u, "");
+        const agentSlug = slugify(node.name) || "agent";
+        const id = `spawnfile-dream-${agentSlug}-${bankSlug}`;
+        jobs.push({
+            createdAtMs: 0,
+            deleteAfterRun: false,
+            enabled: true,
+            id,
+            name: id,
+            payload: {
+                deliver: false,
+                kind: "agent_turn",
+                message: dreamPrompt(access.bank.id, dreamServerName)
+            },
+            schedule: scheduleFromMemoryConsolidation(schedule),
+            state: {},
+            updatedAtMs: 0
+        });
+    }
+    return jobs;
+};
+export const createPicoClawCronJobs = (node) => [
+    createPicoClawCronJob(node),
+    ...createPicoClawMemoryDreamJobs(node)
+].filter((job) => job !== null);
 export const createPicoClawCronStoreFile = (node) => {
-    const job = createPicoClawCronJob(node);
-    if (!job) {
+    const jobs = createPicoClawCronJobs(node);
+    if (jobs.length === 0) {
         return null;
     }
     const store = {
-        jobs: [job],
+        jobs,
         version: 1
     };
     return {
@@ -37,6 +95,7 @@ export const createPicoClawCronStoreFile = (node) => {
         path: "workspace/cron/jobs.json"
     };
 };
+export const hasPicoClawCronJobs = (node) => createPicoClawCronJobs(node).length > 0;
 export const scheduleOutcomeFor = (node) => {
     if (!node.schedule) {
         return {};

package/dist/runtime/registry.js

@@ -3,9 +3,12 @@ import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 import { SpawnfileError } from "../shared/index.js";
 import { openClawAdapter } from "./openclaw/adapter.js";
+import { daimonAdapter, piAdapter } from "./pi/adapter.js";
 import { picoClawAdapter } from "./picoclaw/adapter.js";
 const runtimeAdapters = new Map([
+    [daimonAdapter.name, daimonAdapter],
     [openClawAdapter.name, openClawAdapter],
+    [piAdapter.name, piAdapter],
     [picoClawAdapter.name, picoClawAdapter]
 ]);
 const runtimeInstallSchema = z.discriminatedUnion("kind", [

package/dist/runtime/scheduleUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const isEveryScheduleValue: (value: string) => boolean;
+export declare const parseEveryScheduleMs: (value: string) => number | null;

package/dist/runtime/scheduleUtils.js

@@ -0,0 +1,15 @@
+export const isEveryScheduleValue = (value) => /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/u.test(value.trim());
+export const parseEveryScheduleMs = (value) => {
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/u.exec(value.trim());
+    if (!match) {
+        return null;
+    }
+    const multipliers = {
+        d: 24 * 60 * 60 * 1000,
+        h: 60 * 60 * 1000,
+        m: 60 * 1000,
+        ms: 1,
+        s: 1000
+    };
+    return Math.max(1, Math.round(Number(match[1]) * multipliers[match[2] ?? "ms"]));
+};

package/dist/runtime/types.d.ts

@@ -1,4 +1,5 @@
 import type { EffectiveModelTarget, ResolvedAgentNode, ResolvedAgentSurfaces, ResolvedTeamNode } from "../compiler/types.js";
+import type { SimfileWorldBindingV1 } from "../compiler/worldBindings.js";
 import type { ResolvedAuthProfile } from "../auth/index.js";
 import type { AgentManifest } from "../manifest/index.js";
 import type { CapabilityReport, DiagnosticReport } from "../report/index.js";
@@ -20,17 +21,30 @@ export interface ContainerTargetInput {
     kind: "agent" | "team";
     slug: string;
     value: ResolvedAgentNode | ResolvedTeamNode;
+    worldBinding?: SimfileWorldBindingV1;
 }
 export interface ContainerTargetEnvFile {
     envName: string;
     relativePath: string;
 }
+export type RuntimeContainerConfigValueTransform = "bearer";
 export interface ContainerTarget {
     configEnvBindings?: RuntimeContainerConfigEnvBinding[];
+    /**
+     * Optional node id -> resolved engine kind map (currently only populated by
+     * `src/runtime/pi/adapter.ts`'s `createContainerTargets`, e.g. `{"agent:
+     * eleanor": "scripted"}`). Threaded through `RuntimeTargetPlan` into
+     * `ContainerRuntimeInstanceReport.engine_by_node_id` for compile-report
+     * disclosure (Piece 5, Slice B) — adapters with no engine concept simply
+     * omit it.
+     */
+    engineByNodeId?: Record<string, string>;
     envFiles?: ContainerTargetEnvFile[];
     files: EmittedFile[];
     id: string;
     sourceIds?: string[];
+    /** World token env names actually lowered into this target's native config. */
+    worldTokenEnvNames?: string[];
 }
 export interface RuntimeContainerInstancePaths {
     configPathTemplate: string;
@@ -41,7 +55,9 @@ export interface RuntimeContainerInstancePaths {
 export interface RuntimeContainerConfigEnvBinding {
     envName: string;
     generated?: boolean;
-    jsonPath: string;
+    /** Legacy dot paths remain supported; structured paths address arbitrary JSON keys exactly. */
+    jsonPath: string | readonly string[];
+    transform?: RuntimeContainerConfigValueTransform;
 }
 export interface RuntimeContainerMeta {
     configFileName: string;
@@ -59,6 +75,7 @@ export interface RuntimeContainerMeta {
     port?: number;
     portStride?: number;
     portEnv?: string;
+    postRootfsCommands?: string[];
     standaloneBaseImage: string;
     startCommand: string[];
     staticEnv?: Record<string, string>;
@@ -79,7 +96,14 @@ export interface RuntimeAuthInstance {
     runtime: string;
 }
 export interface RuntimeAuthPreparationInput {
-    authProfile: ResolvedAuthProfile;
+    /**
+     * The Spawnfile-managed auth profile (`--auth-profile`), or `null` when the
+     * run/up invocation did not select one. Host-credential staging that does
+     * not depend on an imported auth profile (e.g. the Pi adapter's optional
+     * CLI-home mounts for grok/codex/antigravity) must still run when this is
+     * `null` — only the profile-derived `imports` lookups are unavailable.
+     */
+    authProfile: ResolvedAuthProfile | null;
     env: Record<string, string>;
     instance: RuntimeAuthInstance;
     outputDirectory: string;

package/dist/shared/errors.d.ts

@@ -1,7 +1,7 @@
 export type SpawnfileErrorCode = "adapter_error" | "compile_error" | "invalid_manifest" | "io_error" | "runtime_error" | "validation_error";
 export declare class SpawnfileError extends Error {
     readonly code: SpawnfileErrorCode;
-    constructor(code: SpawnfileErrorCode, message: string);
+    constructor(code: SpawnfileErrorCode, message: string, options?: ErrorOptions);
 }
 export declare const isSpawnfileError: (value: unknown) => value is SpawnfileError;
 /**

package/dist/shared/errors.js

@@ -1,7 +1,7 @@
 export class SpawnfileError extends Error {
     code;
-    constructor(code, message) {
-        super(message);
+    constructor(code, message, options) {
+        super(message, options);
         this.code = code;
         this.name = "SpawnfileError";
     }

package/dist/shared/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./constants.js";
 export * from "./errors.js";
+export * from "./redaction.js";
 export * from "./types.js";

package/dist/shared/index.js

@@ -1,3 +1,4 @@
 export * from "./constants.js";
 export * from "./errors.js";
+export * from "./redaction.js";
 export * from "./types.js";

package/dist/shared/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare const redactSensitiveText: (text: string) => string;
+export declare const boundedRedactedText: (text: string, limit?: number) => string;

package/dist/shared/redaction.js

@@ -0,0 +1,10 @@
+const redactTokenLikeText = (text) => {
+    let redacted = text;
+    redacted = redacted.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer [REDACTED]");
+    redacted = redacted.replace(/\bmagt_v1_[A-Za-z0-9_-]{16,}\b/g, "[REDACTED]");
+    redacted = redacted.replace(/\b(?:sk|sk-proj)-[A-Za-z0-9_-]{20,}\b/g, "[REDACTED]");
+    redacted = redacted.replace(/\b([A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD)[A-Z0-9_]*=)([^\s"'`]+)/gi, "$1[REDACTED]");
+    return redacted.replace(/(\"([^\"]*(?:api[_-]?key|token|secret|password)[^\"]*)\"\s*:\s*\")([^\"]+)(\")/gi, "$1[REDACTED]$4");
+};
+export const redactSensitiveText = (text) => redactTokenLikeText(text);
+export const boundedRedactedText = (text, limit = 240) => redactSensitiveText(text).replace(/\s+/gu, " ").slice(0, limit);

package/dist/status/buildStatus.d.ts

@@ -4,6 +4,7 @@ export declare const countObservations: (observations: StatusObservation[]) => S
 export declare const getVisibleObservations: (status: StaticStatus) => StatusObservation[];
 export declare const exitCodeForStatus: (status: StaticStatus) => StatusExitCode;
 export declare const createStaticStatus: (view: StaticStatus["view"], loadedReport: LoadedCompileReport, input: {
+    compiledProbeObservations?: StatusObservation[];
     deployments?: StatusDeploymentSummary[];
     inputPath: string;
     liveObservations?: StatusObservation[];

package/dist/status/buildStatus.js

@@ -230,6 +230,7 @@ export const createStaticStatus = (view, loadedReport, input) => {
     const deployments = input.deployments ?? [];
     const live = input.live ?? defaultLiveRequest();
     const liveObservations = input.liveObservations ?? [];
+    const compiledProbeObservations = input.compiledProbeObservations ?? [];
     const selection = expandStatusSelectionSubjects(input.selection, {
         deployments,
         loadedReport,
@@ -237,6 +238,7 @@ export const createStaticStatus = (view, loadedReport, input) => {
     });
     addDeclaredObservations(observations, view, nodes);
     addCompiledObservations(observations, loadedReport, view, nodes);
+    observations.push(...compiledProbeObservations);
     observations.push(...createDeploymentObservations(deployments, {
         compileFingerprint: compileInfoFor(loadedReport).compileFingerprint,
         liveRequested: live.requested,

package/dist/status/compileReport.d.ts

@@ -32,6 +32,10 @@ export interface StatusReportMoltnetRoom {
     visibility: string | null;
     writePolicy: string | null;
 }
+export interface StatusReportMoltnetNodePlan {
+    configPath: string;
+    networkId: string;
+}
 export interface StatusReportMoltnetServerPlan {
     authMode: string | null;
     baseUrl: string;
@@ -66,8 +70,26 @@ export interface StatusReportWorkspaceResource {
 }
 export interface StatusReport {
     compileFingerprint: string | null;
+    /**
+     * Absolute physical path to the compiled `container/entrypoint` script
+     * (B93), resolved against the output directory a given
+     * `loadCompileReport`/`loadedImageCompileReport` call was actually handed
+     * — never a path baked into the report JSON's own `output_directory`
+     * field, which can be stale relative to the current invocation. `null`
+     * when the report has no `container.entrypoint` field, or (image/home
+     * deployment reports) when there is no on-disk compiled output at all.
+     */
+    entrypointPath?: string | null;
     generatedAt: string | null;
     internalPorts?: number[];
+    /**
+     * Parsed `container.moltnet.node_plans[]` (B38): `configPath` is the
+     * container-absolute path from the compiled report (see
+     * `toContainerRootfsPath` in `src/compiler/moltnetArtifactPaths.ts`), not
+     * yet resolved onto disk — join it under `<output dir>/container/rootfs`.
+     * Optional, like `moltnetServers` below, for the same pre-B38 reason.
+     */
+    moltnetNodePlans?: StatusReportMoltnetNodePlan[];
     moltnetServers?: StatusReportMoltnetServerPlan[];
     nodes: StatusReportNode[];
     outputDirectory: string | null;

package/dist/status/compileReport.js

@@ -91,6 +91,14 @@ const normalizeMoltnetRoom = (value) => {
         writePolicy: toStringOrNull(value.write_policy)
     };
 };
+const normalizeMoltnetNodePlan = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const configPath = toStringOrNull(value.config_path);
+    const networkId = toStringOrNull(value.network_id);
+    return configPath && networkId ? { configPath, networkId } : null;
+};
 const normalizeMoltnetServer = (value) => {
     if (!isRecord(value)) {
         return null;
@@ -153,7 +161,7 @@ const normalizeWorkspaceResource = (value) => {
         ? { backingPath, id, kind, linkPath, mode, mount, sharing }
         : null;
 };
-const normalizeReport = (value, reportPath) => {
+const normalizeReport = (value, reportPath, outputDirectory) => {
     if (!isRecord(value) || !Array.isArray(value.nodes)) {
         return null;
     }
@@ -163,10 +171,16 @@ const normalizeReport = (value, reportPath) => {
         : [];
     const moltnet = isRecord(container.moltnet) ? container.moltnet : {};
     const moltnetServers = Array.isArray(moltnet.server_plans) ? moltnet.server_plans : [];
+    const moltnetNodePlans = Array.isArray(moltnet.node_plans) ? moltnet.node_plans : [];
+    const entrypoint = toStringOrNull(container.entrypoint);
     return {
         compileFingerprint: toStringOrNull(value.compile_fingerprint),
+        entrypointPath: entrypoint ? path.join(outputDirectory, entrypoint) : null,
         generatedAt: toStringOrNull(value.generated_at),
         internalPorts: toNumberArray(container.internal_ports),
+        moltnetNodePlans: moltnetNodePlans
+            .map(normalizeMoltnetNodePlan)
+            .filter((entry) => entry !== null),
         moltnetServers: moltnetServers
             .map(normalizeMoltnetServer)
             .filter((entry) => entry !== null),
@@ -219,7 +233,7 @@ export const loadCompileReport = async (outputDirectory) => {
             reportPath
         };
     }
-    const report = normalizeReport(parsed, reportPath);
+    const report = normalizeReport(parsed, reportPath, outputDirectory);
     return report
         ? { kind: "loaded", report, reportPath }
         : {

package/dist/status/compiledProbeCollection.d.ts

@@ -0,0 +1,21 @@
+import type { LoadedCompileReport } from "./compileReport.js";
+import { collectLifecycleProbeObservations } from "./lifecycleProbes.js";
+import { collectMoltnetWiringProbeObservations } from "./moltnetWiringProbes.js";
+import type { StatusObservation } from "./types.js";
+/**
+ * CLI-facing glue for the B38 offline lifecycle + Moltnet-wiring probes:
+ * a real disk `readFile` for the static (`--out <dir>`) status path, a
+ * stub that always resolves `null` for the home-deployment status path
+ * (no compiled output tree exists there at all), and one function that
+ * runs both probe collectors and concatenates their observations. Kept out
+ * of `src/cli/statusCommand.ts` to stay under this repo's 400-line file
+ * cap — this is CLI wiring plumbing, not a new probe contract.
+ */
+export type CompiledProbeReadFile = (filePath: string) => Promise<string | null>;
+export interface CompiledProbeCollectors {
+    collectLifecycleProbeObservations?: typeof collectLifecycleProbeObservations;
+    collectMoltnetWiringProbeObservations?: typeof collectMoltnetWiringProbeObservations;
+}
+export declare const readCompiledProbeFile: CompiledProbeReadFile;
+export declare const unavailableCompiledProbeFile: CompiledProbeReadFile;
+export declare const collectCompiledProbeObservations: (loadedReport: LoadedCompileReport, outputDirectory: string | null, readFileFn: CompiledProbeReadFile, collectors?: CompiledProbeCollectors) => Promise<StatusObservation[]>;

package/dist/status/compiledProbeCollection.js

@@ -0,0 +1,27 @@
+import { readFile } from "node:fs/promises";
+import { collectLifecycleProbeObservations } from "./lifecycleProbes.js";
+import { collectMoltnetWiringProbeObservations } from "./moltnetWiringProbes.js";
+// Never throws: an unreadable path (missing file, permissions, not a
+// regular file) resolves null so a probe reports its own defined
+// unreadable-input severity instead of crashing status.
+export const readCompiledProbeFile = async (filePath) => {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+};
+// Home-deployment status has no on-disk compiled output tree (no `--out`
+// directory, no container/rootfs mirror) to read from at all — every read
+// resolves null so the probes report their own defined "nothing to check"
+// unknown, never a crash and never a false ok.
+export const unavailableCompiledProbeFile = async () => null;
+export const collectCompiledProbeObservations = async (loadedReport, outputDirectory, readFileFn, collectors = {}) => {
+    const collectLifecycle = collectors.collectLifecycleProbeObservations ?? collectLifecycleProbeObservations;
+    const collectWiring = collectors.collectMoltnetWiringProbeObservations ?? collectMoltnetWiringProbeObservations;
+    return [
+        ...await collectLifecycle({ loadedReport, outputDirectory, readFile: readFileFn }),
+        ...await collectWiring({ loadedReport, outputDirectory, readFile: readFileFn })
+    ];
+};