spawnfile 0.1.13 → 0.1.17

package/dist/runtime/pi/adapter.js

@@ -1,59 +1,36 @@
-import path from "node:path";
-import { listExecutionModelSecretNames } from "../../compiler/modelEnv.js";
+import { readUtf8File, resolveProjectPath } from "../../filesystem/index.js";
 import { SpawnfileError } from "../../shared/index.js";
-import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
-import { createPiAgentConfig, PI_PACKAGE_NAME, PI_PACKAGE_VERSION, renderPiApp, renderPiAppConfig, renderPiModelsConfig, renderPiPackageJson } from "./appTemplate.js";
+import { CLI_ENGINE_SKILL_BASE_DIRECTORIES, createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { resolveScriptedEngineCommandOption, resolveScriptedEngineStagedPath } from "./appScriptedEngine.js";
+import { isPiEveryScheduleValue, PI_BUILTIN_TOOLS, PI_ENGINE_KINDS, PI_PACKAGE_NAME, PI_PACKAGE_VERSION, PI_THINKING_FORMATS, PI_THINKING_LEVELS } from "./appTemplate.js";
+import { createPiContainerTargets, PI_CONFIG_FILE, PI_CONTROL_PORT, } from "./containerTargets.js";
 import { preparePiRuntimeAuth } from "./runAuth.js";
-const PI_CONFIG_FILE = "pi-app.json";
-const PI_CONTROL_PORT = 19690;
-const PI_MODELS_FILE = "home/.pi/agent/models.json";
-const moveWorkspaceFileToAgentWorkspace = (file, agentSlug) => {
-    if (!file.path.startsWith("workspace/")) {
-        return file;
-    }
-    const relativePath = file.path.slice("workspace/".length);
-    return {
-        ...file,
-        path: path.posix.join("workspace", "agents", agentSlug, relativePath)
-    };
-};
-const createContainerTargets = async (inputs) => {
-    const agentInputs = inputs.filter((input) => input.kind === "agent" && input.value.kind === "agent");
-    if (agentInputs.length === 0) {
+/**
+ * Stages a `scripted`-engine's `engine_command` script into this agent's
+ * emitted workspace files, the same way `createDocumentFiles`/
+ * `createSkillFiles` stage docs/skills: read once at compile time (relative
+ * to the declaring manifest, via `resolveProjectPath(node.sourcePath ?? node.source, ...)`,
+ * mirroring `surfaces.ts`'s `loadResolvedDocuments`) and emitted as a
+ * `workspace/...` file, which `createContainerTargets` below relocates to
+ * `workspace/agents/<slug>/...` (`moveWorkspaceFileToAgentWorkspace`) just
+ * like every other per-agent workspace file. Returns `[]` for every engine
+ * other than `scripted` (and defensively for a `scripted` engine missing
+ * `engine_command`, though `validateRuntimeOptions` below already rejects
+ * that before `compileAgent` ever runs).
+ */
+const createScriptedEngineFiles = async (node) => {
+    const option = resolveScriptedEngineCommandOption(node);
+    const stagedPath = resolveScriptedEngineStagedPath(node);
+    if (!option || !stagedPath) {
         return [];
     }
-    const agents = agentInputs.map((input) => createPiAgentConfig(input.value, input.slug, input.id));
-    const envFiles = [
-        ...new Set(agentInputs.flatMap((input) => listExecutionModelSecretNames(input.value.execution)))
-    ].map((secretName) => ({
-        envName: secretName,
-        relativePath: `secrets/${secretName}`
-    }));
+    const sourcePath = resolveProjectPath(node.sourcePath ?? node.source, option);
+    const content = await readUtf8File(sourcePath);
     return [
         {
-            envFiles,
-            files: [
-                ...agentInputs.flatMap((input) => input.emittedFiles.map((file) => moveWorkspaceFileToAgentWorkspace(file, input.slug))),
-                {
-                    content: renderPiAppConfig(agents),
-                    path: PI_CONFIG_FILE
-                },
-                {
-                    content: renderPiModelsConfig(agentInputs.map((input) => input.value)),
-                    path: PI_MODELS_FILE
-                },
-                {
-                    content: renderPiPackageJson(),
-                    path: "runtime/package.json"
-                },
-                {
-                    content: renderPiApp(),
-                    mode: 0o755,
-                    path: "runtime/app.mjs"
-                }
-            ],
-            id: "pi-app",
-            sourceIds: agentInputs.map((input) => input.id).sort()
+            content,
+            mode: 0o755,
+            path: `workspace/${stagedPath}`
         }
     ];
 };
@@ -77,6 +54,13 @@ const createScheduleDiagnostics = (node) => node.schedule?.kind === "cron"
         createDiagnostic("warn", "Pi generated runtime app supports every schedules in Spawnfile v0.1; cron schedules are degraded")
     ]
     : [];
+const createMemoryConsolidationDiagnostics = (node) => (node.memoryAccess ?? []).flatMap((access) => access.bank.consolidation.mode === "scheduled" &&
+    access.bank.consolidation.schedule &&
+    !isPiEveryScheduleValue(access.bank.consolidation.schedule)
+    ? [
+        createDiagnostic("warn", `Pi generated runtime app supports every memory consolidation schedules in Spawnfile v0.1; memory bank ${access.bank.id} consolidation is degraded`)
+    ]
+    : []);
 const moltnetCapabilityOptions = (node) => node.surfaces?.moltnet
     ? {
         moltnetMessage: "Pi generated runtime app exposes a control endpoint for Moltnet bridge wake delivery",
@@ -138,9 +122,15 @@ export const piAdapter = {
         },
         port: PI_CONTROL_PORT,
         portEnv: "SPAWNFILE_PI_CONTROL_PORT",
+        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex@0.142.3"],
+        postRootfsCommands: [
+            "curl -fsSL https://x.ai/cli/install.sh | GROK_BIN_DIR=/usr/local/bin bash",
+            "if [ -L /usr/local/bin/grok ]; then cp -L /usr/local/bin/grok /usr/local/bin/grok.real && mv /usr/local/bin/grok.real /usr/local/bin/grok && chmod 0755 /usr/local/bin/grok && ln -sf /usr/local/bin/grok /usr/local/bin/agent; fi",
+            "curl -fsSL https://antigravity.google/cli/install.sh | bash -s -- --dir /usr/local/bin"
+        ],
         standaloneBaseImage: "node:24-bookworm-slim",
         startCommand: ["node", "<runtime-root>/app.mjs", "<config-path>"],
-        systemDeps: ["bash", "ca-certificates", "curl", "git", "procps"]
+        systemDeps: ["bash", "ca-certificates", "curl", "git", "procps", "tar"]
     },
     systemInstructionSurface: {
         placement: "append_pointer",
@@ -152,6 +142,8 @@ export const piAdapter = {
         const scheduleOutcome = scheduleOutcomeFor(node);
         return {
             capabilities: createAgentCapabilities(node, {
+                memoryMessage: "Daimon exposes Mneme memory through generated runtime turns",
+                memoryOutcome: "supported",
                 ...moltnetCapabilityOptions(node),
                 mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
                 sandboxOutcome: node.execution?.sandbox ? "degraded" : "supported",
@@ -161,6 +153,7 @@ export const piAdapter = {
             }),
             diagnostics: [
                 ...createScheduleDiagnostics(node),
+                ...createMemoryConsolidationDiagnostics(node),
                 ...(node.execution?.sandbox
                     ? [createDiagnostic("warn", "Pi runtime relies on container and workspace isolation; Pi itself is not a sandbox engine")]
                     : []),
@@ -173,26 +166,62 @@ export const piAdapter = {
             ],
             files: [
                 ...createDocumentFiles("workspace", node.docs),
-                ...createSkillFiles("workspace/skills", node.skills)
+                ...createSkillFiles(CLI_ENGINE_SKILL_BASE_DIRECTORIES, node.skills),
+                ...(await createScriptedEngineFiles(node))
             ]
         };
     },
     async createContainerTargets(inputs) {
-        return createContainerTargets(inputs);
+        return createPiContainerTargets(inputs);
     },
     name: "pi",
     prepareRuntimeAuth: preparePiRuntimeAuth,
     validateRuntimeOptions(options) {
         const diagnostics = [];
-        const unsupported = Object.keys(options).filter((key) => key !== "restrict_to_workspace");
+        if (options.engine !== undefined &&
+            (typeof options.engine !== "string" ||
+                !PI_ENGINE_KINDS.includes(options.engine))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option engine must be one of ${PI_ENGINE_KINDS.join(", ")}`));
+        }
+        if (options.engine === "scripted" &&
+            (typeof options.engine_command !== "string" || options.engine_command.trim().length === 0)) {
+            diagnostics.push(createDiagnostic("error", "Pi runtime option engine_command is required (a fixture-relative script path) when engine is scripted"));
+        }
+        if (options.thinking !== undefined &&
+            (typeof options.thinking !== "string" ||
+                !PI_THINKING_LEVELS.includes(options.thinking))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option thinking must be one of ${PI_THINKING_LEVELS.join(", ")}`));
+        }
+        if (options.thinking_format !== undefined &&
+            (typeof options.thinking_format !== "string" ||
+                !PI_THINKING_FORMATS.includes(options.thinking_format))) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option thinking_format must be one of ${PI_THINKING_FORMATS.join(", ")}`));
+        }
+        if (options.tools !== undefined &&
+            (!Array.isArray(options.tools)
+                || options.tools.some((item) => typeof item !== "string"
+                    || !PI_BUILTIN_TOOLS.includes(item))
+                || new Set(options.tools).size !== options.tools.length)) {
+            diagnostics.push(createDiagnostic("error", `Pi runtime option tools must contain unique values from ${PI_BUILTIN_TOOLS.join(", ")}`));
+        }
+        if (options.raw_training_capture_turns !== undefined
+            && (!Number.isSafeInteger(options.raw_training_capture_turns)
+                || typeof options.raw_training_capture_turns !== "number"
+                || options.raw_training_capture_turns < 1
+                || options.raw_training_capture_turns > 100_000)) {
+            diagnostics.push(createDiagnostic("error", "Pi runtime option raw_training_capture_turns must be an integer between 1 and 100000"));
+        }
+        const unsupported = Object.keys(options).filter((key) => key !== "restrict_to_workspace"
+            && key !== "engine"
+            && key !== "engine_command"
+            && key !== "thinking"
+            && key !== "thinking_format"
+            && key !== "tools"
+            && key !== "raw_training_capture_turns");
         for (const key of unsupported) {
             diagnostics.push(createDiagnostic("warn", `Pi runtime option ${key} is not used yet`));
         }
         return diagnostics;
     }
 };
-export const daimonAdapter = {
-    ...piAdapter,
-    name: "daimon"
-};
 export const PI_RUNTIME_PACKAGE = `${PI_PACKAGE_NAME}@${PI_PACKAGE_VERSION}`;

package/dist/runtime/pi/appActivitySource.js

@@ -1,7 +1,7 @@
 export const renderPiActivitySource = () => String.raw `
 const maxActivityEvents = 500;
 
-const createActivityBroker = () => {
+const createActivityBroker = (options = {}) => {
   let sequence = 0;
   const events = [];
   const clients = new Set();
@@ -33,6 +33,9 @@ const createActivityBroker = () => {
     if (events.length > maxActivityEvents) {
       events.splice(0, events.length - maxActivityEvents);
     }
+    if (typeof options.logPath === "string" && options.logPath.length > 0) {
+      appendFileSync(options.logPath, JSON.stringify(full) + "\n", "utf8");
+    }
     const frame = "data: " + JSON.stringify(full) + "\n\n";
     for (const client of [...clients]) {
       if (!matchesFilter(full, client.filter)) {
@@ -76,12 +79,121 @@ const redactActivityText = (value) => {
   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(
-    /("([^"]*(?:api[_-]?key|token|secret|password)[^"]*)"\s*:\s*")([^"]+)(")/gi,
+    /("([^"]*(?:api[_-]?key|authorization|credential|password|secret|session[_-]?key|token)[^"]*)"\s*:\s*")([^"]+)(")/gi,
     "$1[REDACTED]$4"
   );
+  redacted = redacted.replace(
+    /\b((?:api[_-]?key|authorization|credential|password|secret|session\s+key|session[_-]?key|token)\s*[:=]\s*)([^\r\n]+)/gi,
+    "$1[REDACTED]"
+  );
   redacted = redacted.replace(/\/(?:Users|home|private|tmp|var|opt|run)\/[^\s"']+/g, "[path]");
   return redacted.length > 1000 ? redacted.slice(0, 1000) + "..." : redacted;
 };
 
 const formatActivityError = (error) => redactActivityText(error instanceof Error ? error.message : String(error));
+
+const traceSha256 = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+
+const sensitiveTraceKeyPattern = /(?:api[_-]?key|authorization|credential|password|secret|session[_-]?key|token)/iu;
+
+const sanitizeTraceValue = (value, key = "") => {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (sensitiveTraceKeyPattern.test(String(key))) {
+    return "[REDACTED]";
+  }
+  if (typeof value === "string") {
+    return redactActivityText(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeTraceValue(entry));
+  }
+  if (typeof value === "object") {
+    const sanitized = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+      sanitized[entryKey] = sanitizeTraceValue(entryValue, entryKey);
+    }
+    return sanitized;
+  }
+  return redactActivityText(String(value));
+};
+
+const summarizeTurnPrompt = (prompt) => ({
+  chars: typeof prompt === "string" ? prompt.length : 0,
+  has_active_environment: typeof prompt === "string" && prompt.includes("Active environment context:"),
+  has_dream_mode: typeof prompt === "string" && prompt.includes("## Dream Mode"),
+  has_memory_context: typeof prompt === "string" && prompt.includes("Memory context"),
+  lines: typeof prompt === "string" && prompt.length > 0 ? prompt.split(/\r?\n/u).length : 0,
+  sha256: traceSha256(typeof prompt === "string" ? prompt : "")
+});
+
+const sanitizeTraceFileId = (value) => {
+  const normalized = String(value).replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 128);
+  return normalized.length > 0 ? normalized : "turn";
+};
+
+const turnTracePath = (paths, wakeId) =>
+  path.join(paths.runtimeHomePath, "telemetry", "turns", sanitizeTraceFileId(wakeId) + ".json");
+
+const writeTurnTrace = async (paths, record) => {
+  const telemetryPath = path.join(paths.runtimeHomePath, "telemetry");
+  const turnsPath = path.join(telemetryPath, "turns");
+  await mkdir(turnsPath, { recursive: true });
+  await writeFile(turnTracePath(paths, record.turn_id), JSON.stringify(record, null, 2) + "\n", "utf8");
+  await writeFile(path.join(telemetryPath, "turns.ndjson"), JSON.stringify(record) + "\n", { flag: "a" });
+};
+
+const createGeneratedTurnTrace = (input) => ({
+  agent_id: input.config.id,
+  completed_at: new Date().toISOString(),
+  engine: {
+    auth_method: input.config.model?.auth_method ?? "unknown",
+    kind: input.engine,
+    model: input.config.model?.name ?? "unknown",
+    provider: input.config.model?.provider ?? "unknown"
+  },
+  ...(input.error ? { error: { message: formatActivityError(input.error), stage: input.errorStage ?? "wake" } } : {}),
+  memory: {
+    enabled: Boolean(input.config.memory),
+    ...(input.memoryPrepareMs !== undefined || input.memoryRecall ? {
+      prepare: {
+        duration_ms: input.memoryPrepareMs ?? 0,
+        ...(input.memoryRecall ? { recall: input.memoryRecall } : {}),
+        status: input.memoryPrepareStatus ?? "completed"
+      }
+    } : {}),
+    ...(input.memoryRecordMs !== undefined ? { record_ms: input.memoryRecordMs } : {})
+  },
+  prompt: summarizeTurnPrompt(input.prompt),
+  reply: {
+    output_chars: input.outputText.length,
+    reply_given: input.outputText.trim().length > 0
+  },
+  schema: "daimon.turn_trace.v1",
+  session: {
+    mode: input.event.kind === "dream" ? "dream" : "awake",
+    thread_id: input.event.context_id ? redactActivityText(input.event.context_id) : input.event.id
+  },
+  started_at: input.startedAt.toISOString(),
+  status: input.status,
+  timings_ms: {
+    ...(input.engineMs !== undefined ? { engine_prompt: input.engineMs } : {}),
+    ...(input.memoryPrepareMs !== undefined ? { memory_prepare: input.memoryPrepareMs } : {}),
+    ...(input.memoryRecordMs !== undefined ? { memory_record: input.memoryRecordMs } : {}),
+    total: Date.now() - input.startedAt.getTime()
+  },
+  tools: [],
+  turn_id: input.event.id,
+  wake: {
+    ...(input.event.context ? { context: sanitizeTraceValue(input.event.context) } : {}),
+    ...(input.event.context_id ? { context_id: redactActivityText(input.event.context_id) } : {}),
+    event_id: input.event.id,
+    ...(input.event.from ? { from: redactActivityText(input.event.from) } : {}),
+    kind: input.event.kind
+  }
+});
 `;

package/dist/runtime/pi/appAgentConfig.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { SimfileWorldBindingV1 } from "../../compiler/worldBindings.js";
+import { PI_THINKING_FORMATS, type PiGeneratedAgent } from "./appTemplateTypes.js";
+export declare const isPiEveryScheduleValue: (value: string) => boolean;
+export declare const resolvePiEngine: (node: ResolvedAgentNode) => PiGeneratedAgent["engine"];
+export declare const resolvePiThinkingLevel: (node: ResolvedAgentNode) => PiGeneratedAgent["thinking_level"] | undefined;
+export declare const resolvePiTools: (node: ResolvedAgentNode) => string[];
+export declare const resolvePiThinkingFormat: (node: ResolvedAgentNode) => (typeof PI_THINKING_FORMATS)[number] | undefined;
+export declare const resolvePiRawTrainingCapture: (node: ResolvedAgentNode) => PiGeneratedAgent["raw_training_capture"] | undefined;
+export declare const renderPiModelsConfig: (nodes: ResolvedAgentNode[]) => string;
+export declare const createPiAgentConfig: (node: ResolvedAgentNode, slug: string, id: string, worldBinding?: SimfileWorldBindingV1) => PiGeneratedAgent;

package/dist/runtime/pi/appAgentConfig.js

@@ -0,0 +1,264 @@
+import path from "node:path";
+import { listEffectiveExecutionModelTargets, resolveModelProviderEnvName } from "../../compiler/modelEnv.js";
+import { createShortHash, slugify, stableStringify } from "../../compiler/helpers.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { resolveScriptedEngineStagedPath } from "./appScriptedEngine.js";
+import { PI_BUILTIN_TOOLS, PI_ENGINE_KINDS, PI_HARNESS_SYSTEM_PROMPT, PI_THINKING_FORMATS, PI_THINKING_LEVELS } from "./appTemplateTypes.js";
+const serializeJson = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const isPiEveryScheduleValue = (value) => /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/u.test(value.trim());
+const isPiEngineKind = (value) => typeof value === "string" && PI_ENGINE_KINDS.includes(value);
+const isPiThinkingLevel = (value) => typeof value === "string" && PI_THINKING_LEVELS.includes(value);
+const isPiThinkingFormat = (value) => typeof value === "string" && PI_THINKING_FORMATS.includes(value);
+const formatDocumentInstructions = (node) => node.docs
+    .map((document) => `# ${document.role}\n\n${document.content}`)
+    .join("\n\n");
+const createCustomProviderId = (target) => {
+    const base = slugify(`${target.provider}-${target.endpoint?.compatibility ?? "builtin"}-${target.name}`);
+    return `${base || "model"}-${createShortHash(stableStringify({
+        auth: target.auth,
+        endpoint: target.endpoint,
+        name: target.name,
+        provider: target.provider
+    }))}`;
+};
+const resolveEndpointApi = (compatibility) => compatibility === "anthropic" ? "anthropic-messages" : "openai-completions";
+const OPENAI_THINKING_LEVEL_MAP = Object.freeze({
+    high: "high",
+    low: "low",
+    medium: "medium",
+    minimal: "low",
+    off: "none",
+    xhigh: "max"
+});
+const resolveEndpointApiKey = (target) => target.auth.method === "api_key"
+    ? `$${target.auth.key ?? resolveModelProviderEnvName(target.provider)}`
+    : "ollama";
+const resolvePiModel = (node) => {
+    const [target] = listEffectiveExecutionModelTargets(node.execution);
+    if (!target) {
+        return {
+            auth_method: "codex",
+            name: "gpt-5.4-mini",
+            provider: "openai-codex"
+        };
+    }
+    if (target.endpoint) {
+        return {
+            auth_method: target.auth.method,
+            name: target.name,
+            provider: createCustomProviderId(target)
+        };
+    }
+    if (target.provider === "openai" && target.auth.method === "codex") {
+        return {
+            auth_method: target.auth.method,
+            name: target.name,
+            provider: "openai-codex"
+        };
+    }
+    return {
+        auth_method: target.auth.method,
+        name: target.name,
+        provider: target.provider
+    };
+};
+export const resolvePiEngine = (node) => {
+    const value = node.runtime.options.engine;
+    if (value === undefined) {
+        return { kind: "pi" };
+    }
+    if (isPiEngineKind(value)) {
+        return { kind: value };
+    }
+    throw new SpawnfileError("validation_error", `Pi runtime option engine must be one of ${PI_ENGINE_KINDS.join(", ")}`);
+};
+export const resolvePiThinkingLevel = (node) => {
+    const value = node.runtime.options.thinking;
+    if (value === undefined)
+        return undefined;
+    if (isPiThinkingLevel(value))
+        return value;
+    throw new SpawnfileError("validation_error", `Pi runtime option thinking must be one of ${PI_THINKING_LEVELS.join(", ")}`);
+};
+export const resolvePiTools = (node) => {
+    const value = node.runtime.options.tools;
+    if (value === undefined)
+        return [...PI_BUILTIN_TOOLS];
+    if (Array.isArray(value)
+        && value.every((item) => typeof item === "string"
+            && PI_BUILTIN_TOOLS.includes(item))
+        && new Set(value).size === value.length) {
+        return [...value];
+    }
+    throw new SpawnfileError("validation_error", `Pi runtime option tools must contain unique values from ${PI_BUILTIN_TOOLS.join(", ")}`);
+};
+export const resolvePiThinkingFormat = (node) => {
+    const value = node.runtime.options.thinking_format;
+    if (value === undefined)
+        return undefined;
+    if (isPiThinkingFormat(value))
+        return value;
+    throw new SpawnfileError("validation_error", `Pi runtime option thinking_format must be one of ${PI_THINKING_FORMATS.join(", ")}`);
+};
+export const resolvePiRawTrainingCapture = (node) => {
+    const value = node.runtime.options.raw_training_capture_turns;
+    if (value === undefined)
+        return undefined;
+    if (Number.isSafeInteger(value)
+        && typeof value === "number"
+        && value >= 1
+        && value <= 100_000) {
+        return {
+            enabled: true,
+            retention: { maxTurns: value }
+        };
+    }
+    throw new SpawnfileError("validation_error", "Pi runtime option raw_training_capture_turns must be an integer between 1 and 100000");
+};
+export const renderPiModelsConfig = (nodes) => {
+    const providers = new Map();
+    for (const node of nodes) {
+        for (const target of listEffectiveExecutionModelTargets(node.execution)) {
+            if (!target.endpoint) {
+                continue;
+            }
+            const providerId = createCustomProviderId(target);
+            const api = resolveEndpointApi(target.endpoint.compatibility);
+            const provider = providers.get(providerId) ?? {
+                api,
+                apiKey: resolveEndpointApiKey(target),
+                baseUrl: target.endpoint.base_url,
+                models: []
+            };
+            if (!provider.models.some((model) => model.id === target.name)) {
+                const explicitOpenAiThinking = target.endpoint.compatibility === "openai"
+                    && node.runtime.options.thinking !== undefined;
+                const thinkingFormat = resolvePiThinkingFormat(node);
+                provider.models.push({
+                    api,
+                    baseUrl: target.endpoint.base_url,
+                    contextWindow: 128000,
+                    cost: {
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        input: 0,
+                        output: 0
+                    },
+                    id: target.name,
+                    input: ["text"],
+                    maxTokens: 16384,
+                    name: target.name,
+                    reasoning: explicitOpenAiThinking,
+                    ...(thinkingFormat === undefined || thinkingFormat === "openai"
+                        ? {}
+                        : { compat: { thinkingFormat } }),
+                    ...(explicitOpenAiThinking
+                        ? { thinkingLevelMap: OPENAI_THINKING_LEVEL_MAP }
+                        : {})
+                });
+            }
+            providers.set(providerId, provider);
+        }
+    }
+    return serializeJson({
+        providers: Object.fromEntries([...providers.entries()].sort(([left], [right]) => left.localeCompare(right)))
+    });
+};
+const resolveSchedule = (node) => {
+    if (!node.schedule || node.schedule.kind === "disabled") {
+        return node.schedule ? { kind: "disabled" } : undefined;
+    }
+    if (node.schedule.kind === "every") {
+        return {
+            every: node.schedule.every,
+            kind: "every",
+            ...(node.schedule.prompt ? { prompt: node.schedule.prompt } : {})
+        };
+    }
+    return undefined;
+};
+const resolveMemoryRuntimeHomePath = (node) => {
+    const [access] = [...(node.memoryAccess ?? [])].sort((left, right) => `${left.source}:${left.bank.id}`.localeCompare(`${right.source}:${right.bank.id}`));
+    if (!access) {
+        return undefined;
+    }
+    const store = access.bank.store;
+    if (store.kind === "postgres") {
+        return undefined;
+    }
+    const vector = access.bank.index?.vector;
+    const embedding = vector?.enabled && vector.model && (!vector.provider || vector.provider === "ollama")
+        ? {
+            ...(vector.base_url ? { base_url: vector.base_url } : {}),
+            ...(vector.dimensions ? { dimensions: vector.dimensions } : {}),
+            model: vector.model,
+            provider: "ollama",
+            ...(vector.timeout_ms ? { timeout_ms: vector.timeout_ms } : {})
+        }
+        : undefined;
+    if (store.kind === "memory") {
+        return {
+            bank_id: access.bank.id,
+            ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
+            ...(embedding ? { embedding } : {}),
+            runtime_home_path: `/var/lib/spawnfile/memory/${slugify(access.bank.declaredName) || "memory"}/${access.bank.id}`,
+            source: `spawnfile:${access.declaringKind}:${access.bank.id}`
+        };
+    }
+    const runtimeHomePath = store.persistence?.mount ?? path.posix.dirname(store.path ?? "");
+    if (!runtimeHomePath) {
+        return undefined;
+    }
+    return {
+        bank_id: access.bank.id,
+        ...(resolveMemoryConsolidation(access) ? { consolidation: resolveMemoryConsolidation(access) } : {}),
+        ...(embedding ? { embedding } : {}),
+        runtime_home_path: runtimeHomePath,
+        source: `spawnfile:${access.declaringKind}:${access.bank.id}`
+    };
+};
+const resolveMemoryConsolidation = (access) => {
+    if (access.bank.consolidation.mode !== "scheduled" || !access.bank.consolidation.schedule) {
+        return undefined;
+    }
+    if (!isPiEveryScheduleValue(access.bank.consolidation.schedule)) {
+        return undefined;
+    }
+    return {
+        every: access.bank.consolidation.schedule,
+        kind: "every",
+        prompt: [
+            `Dream over Mneme memory bank ${access.bank.id}.`,
+            "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(" ")
+    };
+};
+export const createPiAgentConfig = (node, slug, id, worldBinding) => {
+    const engineCommand = resolveScriptedEngineStagedPath(node);
+    const engine = resolvePiEngine(node);
+    const thinkingLevel = resolvePiThinkingLevel(node);
+    const rawTrainingCapture = resolvePiRawTrainingCapture(node);
+    return {
+        engine,
+        ...(engineCommand ? { engine_command: engineCommand } : {}),
+        id,
+        instructions: [
+            `You are ${node.name}.`,
+            node.description,
+            formatDocumentInstructions(node),
+            PI_HARNESS_SYSTEM_PROMPT
+        ].filter((part) => part.trim().length > 0).join("\n\n"),
+        model: resolvePiModel(node),
+        ...(resolveMemoryRuntimeHomePath(node) ? { memory: resolveMemoryRuntimeHomePath(node) } : {}),
+        name: node.name,
+        ...(rawTrainingCapture ? { raw_training_capture: rawTrainingCapture } : {}),
+        ...(resolveSchedule(node) ? { schedule: resolveSchedule(node) } : {}),
+        slug,
+        ...(thinkingLevel ? { thinking_level: thinkingLevel } : {}),
+        tools: resolvePiTools(node),
+        ...(worldBinding && engine.kind === "pi"
+            ? { world: { url: worldBinding.json.url, tokenEnv: worldBinding.token_env } }
+            : {})
+    };
+};

package/dist/runtime/pi/appCliEnginesSource.d.ts

@@ -0,0 +1 @@
+export declare const renderPiCliEnginesSource: () => string;