spawnfile 0.1.13 → 0.1.14

package/dist/runtime/mnemeMcp.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+import path from "node:path/posix";
+import { slugify } from "../compiler/helpers.js";
+export const MNEME_PACKAGE = "@noopolis/mneme@0.1.1";
+export const resolveMnemeMemoryRuntimeHomePath = (access) => {
+    const store = access.bank.store;
+    if (store.kind !== "sqlite" && store.kind !== "json") {
+        return null;
+    }
+    if (store.persistence?.mount) {
+        return store.persistence.mount;
+    }
+    return store.path ? path.dirname(store.path) : null;
+};
+export const isMnemeMemoryAccessSupported = (access) => resolveMnemeMemoryRuntimeHomePath(access) !== null;
+const memoryAccessKey = (access) => `${access.source}:${access.bank.id}`;
+const sourceDiscriminatorFor = (access) => {
+    const nameSlug = slugify(`${access.declaringKind}-${access.bank.declaredName}`) || access.declaringKind;
+    const sourceHash = createHash("sha256").update(access.source).digest("hex").slice(0, 8);
+    return `${nameSlug}-${sourceHash}`;
+};
+const hasDuplicateBankId = (node, access) => {
+    const keys = new Set((node.memoryAccess ?? [])
+        .filter(isMnemeMemoryAccessSupported)
+        .filter((candidate) => candidate.bank.id === access.bank.id)
+        .map(memoryAccessKey));
+    return keys.size > 1;
+};
+export const mnemeMemoryServerBaseName = (node, access) => {
+    const bankSlug = slugify(access.bank.id) || "memory";
+    const sourceSuffix = hasDuplicateBankId(node, access) ? `-${sourceDiscriminatorFor(access)}` : "";
+    return `mneme-${bankSlug}${sourceSuffix}`;
+};
+export const mnemeMemoryServerName = (node, access, mode) => {
+    const baseName = mnemeMemoryServerBaseName(node, access);
+    return mode === "dream" ? `${baseName}-dream` : baseName;
+};
+const embeddingArgsFor = (access) => {
+    const vector = access.bank.index.vector;
+    if (!vector.enabled || !vector.model) {
+        return [];
+    }
+    const provider = vector.provider ?? "ollama";
+    if (provider !== "ollama") {
+        return [];
+    }
+    return [
+        "--embedding-provider",
+        provider,
+        "--embedding-model",
+        vector.model,
+        ...(vector.base_url ? ["--embedding-base-url", vector.base_url] : []),
+        ...(vector.dimensions ? ["--embedding-dimensions", String(vector.dimensions)] : []),
+        ...(vector.timeout_ms ? ["--embedding-timeout-ms", String(vector.timeout_ms)] : [])
+    ];
+};
+export const buildMnemeMemoryMcpServers = (node, options = {}) => {
+    const result = {};
+    const seen = new Set();
+    const modes = options.modes ?? ["awake"];
+    for (const access of node.memoryAccess ?? []) {
+        const runtimeHome = resolveMnemeMemoryRuntimeHomePath(access);
+        if (!runtimeHome) {
+            continue;
+        }
+        const key = `${access.source}:${access.bank.id}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        for (const mode of modes) {
+            const name = mnemeMemoryServerName(node, access, mode);
+            result[name] = {
+                enabled: true,
+                command: "mneme",
+                args: [
+                    "mcp",
+                    "--runtime-home",
+                    runtimeHome,
+                    "--agent-id",
+                    slugify(node.name) || "agent",
+                    "--mode",
+                    mode,
+                    "--source",
+                    `spawnfile:${access.declaringKind}:${access.bank.id}`,
+                    ...embeddingArgsFor(access)
+                ]
+            };
+        }
+    }
+    return result;
+};
+export const hasScheduledMemoryConsolidation = (node) => (node.memoryAccess ?? []).some((access) => isMnemeMemoryAccessSupported(access) &&
+    access.bank.consolidation.mode === "scheduled" &&
+    Boolean(access.bank.consolidation.schedule));
+export const hasUnsupportedMnemeMemoryAccess = (node) => {
+    const checked = new Set();
+    for (const access of node.memoryAccess ?? []) {
+        const key = `${access.source}:${access.bank.id}`;
+        if (checked.has(key)) {
+            continue;
+        }
+        checked.add(key);
+        if (!resolveMnemeMemoryRuntimeHomePath(access)) {
+            return true;
+        }
+    }
+    return false;
+};

package/dist/runtime/openclaw/adapter.js

@@ -6,6 +6,9 @@ import { prepareOpenClawRuntimeAuth } from "./runAuth.js";
 import { createOpenClawAgentScaffold } from "./scaffold.js";
 import { assertSupportedOpenClawSurfaces, buildOpenClawChannelConfig, buildOpenClawSurfaceEnvBindings } from "./surfaces.js";
 import { buildOpenClawMoltnetConfig, buildOpenClawMoltnetEnvBindings, validateOpenClawMoltnetRuntimeOptions } from "./moltnet.js";
+import { buildOpenClawMcpConfig, buildOpenClawMcpEnvBindings, openClawMemoryCapabilityFor } from "./mcp.js";
+import { MNEME_PACKAGE } from "../mnemeMcp.js";
+import { createOpenClawCronStoreFile } from "./schedules.js";
 import { openClawStatusProbes } from "./statusProbes.js";
 const buildEnvSecretRef = (envName) => ({
     id: envName,
@@ -88,6 +91,10 @@ const buildOpenClawConfig = (node) => {
     if (moltnet) {
         config.moltnet = moltnet;
     }
+    const mcp = buildOpenClawMcpConfig(node);
+    if (mcp) {
+        config.mcp = mcp;
+    }
     // Bake the import-auth (claude-code/codex) OAuth structure at compile time so
     // the image is self-sufficient; only the credential tokens are injected later.
     const authBaked = applyOpenClawImportAuthConfig(config, resolveOpenClawImportAuthModes(node));
@@ -118,6 +125,7 @@ const createContainerTargets = async (inputs) => inputs.map((input) => {
             ]
             : []),
         ...(buildOpenClawSurfaceEnvBindings(agent?.surfaces) ?? []),
+        ...(agent ? buildOpenClawMcpEnvBindings(agent.mcpServers) : []),
         ...(agent ? (buildOpenClawMoltnetEnvBindings(agent.runtime.options) ?? []) : [])
     ];
     return {
@@ -164,6 +172,7 @@ export const openClawAdapter = {
                 required: true
             }
         ],
+        globalNpmPackages: [MNEME_PACKAGE],
         homeEnv: "OPENCLAW_HOME",
         instancePaths: {
             configPathTemplate: "<instance-root>/home/.openclaw/<config-file>",
@@ -194,23 +203,25 @@ export const openClawAdapter = {
         }
     },
     async compileAgent(node) {
+        const memoryCapability = openClawMemoryCapabilityFor(node);
+        const cronStoreFile = createOpenClawCronStoreFile(node);
         return {
             capabilities: createAgentCapabilities(node, {
-                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported",
+                memoryMessage: memoryCapability.message,
+                memoryOutcome: memoryCapability.outcome,
+                mcpOutcome: "supported",
                 subagentOutcome: node.subagents.length > 0 ? "degraded" : "supported"
             }),
             diagnostics: [
                 ...(node.subagents.length > 0
                     ? [createDiagnostic("warn", "OpenClaw subagents lower to routed sessions in v0.1")]
-                    : []),
-                ...(node.mcpServers.length > 0
-                    ? [createDiagnostic("warn", "OpenClaw MCP goes through mcporter bridge; direct config may not apply")]
                     : [])
             ],
             files: [
                 ...createDocumentFiles("workspace", node.docs),
                 ...createSkillFiles("workspace/skills", node.skills),
                 ...createOpenClawStateFiles(),
+                ...(cronStoreFile ? [cronStoreFile] : []),
                 {
                     content: buildOpenClawConfig(node),
                     path: "openclaw.json"

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

@@ -0,0 +1,10 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { McpServer } from "../../manifest/index.js";
+import type { RuntimeContainerConfigEnvBinding } from "../types.js";
+export declare const buildOpenClawAuthoredMcpServers: (servers: McpServer[]) => Record<string, Record<string, unknown>>;
+export declare const buildOpenClawMcpConfig: (node: ResolvedAgentNode) => Record<string, unknown> | undefined;
+export declare const buildOpenClawMcpEnvBindings: (servers: McpServer[]) => RuntimeContainerConfigEnvBinding[];
+export declare const openClawMemoryCapabilityFor: (node: ResolvedAgentNode) => {
+    message: string;
+    outcome: "degraded" | "supported";
+};

package/dist/runtime/openclaw/mcp.js

@@ -0,0 +1,69 @@
+import { buildMnemeMemoryMcpServers, hasScheduledMemoryConsolidation, hasUnsupportedMnemeMemoryAccess } from "../mnemeMcp.js";
+const buildOpenClawAuthHeaders = (server) => server.auth
+    ? { [server.auth.mode === "bearer" ? "Authorization" : server.auth.secret]: "" }
+    : undefined;
+export const buildOpenClawAuthoredMcpServers = (servers) => {
+    const result = Object.create(null);
+    for (const server of servers) {
+        if (server.transport === "stdio" && server.auth?.mode === "bearer") {
+            throw new Error("OpenClaw stdio MCP servers do not support bearer auth");
+        }
+        const entry = { enabled: true };
+        if (server.transport === "stdio") {
+            entry.transport = "stdio";
+            entry.command = server.command;
+            if (server.args)
+                entry.args = server.args;
+            if (server.env)
+                entry.env = server.env;
+        }
+        else {
+            entry.transport = server.transport === "streamable_http" ? "streamable-http" : "sse";
+            entry.url = server.url;
+            const headers = buildOpenClawAuthHeaders(server);
+            if (headers)
+                entry.headers = headers;
+        }
+        result[server.name] = entry;
+    }
+    return result;
+};
+export const buildOpenClawMcpConfig = (node) => {
+    const servers = {
+        ...buildOpenClawAuthoredMcpServers(node.mcpServers),
+        ...buildMnemeMemoryMcpServers(node, {
+            modes: hasScheduledMemoryConsolidation(node) ? ["awake", "dream"] : ["awake"]
+        })
+    };
+    if (Object.keys(servers).length === 0) {
+        return undefined;
+    }
+    return { servers };
+};
+export const buildOpenClawMcpEnvBindings = (servers) => servers.flatMap((server) => server.auth
+    ? [
+        {
+            envName: server.auth.secret,
+            jsonPath: [
+                "mcp",
+                "servers",
+                server.name,
+                "headers",
+                server.auth.mode === "bearer" ? "Authorization" : server.auth.secret
+            ],
+            ...(server.auth.mode === "bearer" ? { transform: "bearer" } : {})
+        }
+    ]
+    : []);
+export const openClawMemoryCapabilityFor = (node) => {
+    if (hasUnsupportedMnemeMemoryAccess(node)) {
+        return {
+            message: "OpenClaw lowers file-backed Mneme memory through generated MCP servers; non-file stores are not lowered",
+            outcome: "degraded"
+        };
+    }
+    return {
+        message: "OpenClaw accesses Mneme memory through generated MCP servers",
+        outcome: "supported"
+    };
+};

package/dist/runtime/openclaw/runAuth.js

@@ -44,10 +44,10 @@ export const prepareOpenClawRuntimeAuth = 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 codex = input.authProfile.imports.codex
+    const codex = input.authProfile?.imports.codex
         ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
         : null;
     const coveredModelSecrets = [];

package/dist/runtime/openclaw/scaffold.js

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

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

@@ -0,0 +1,38 @@
+import type { ResolvedAgentNode } from "../../compiler/types.js";
+import type { EmittedFile } from "../types.js";
+type OpenClawCronSchedule = {
+    anchorMs?: number;
+    everyMs: number;
+    kind: "every";
+} | {
+    expr: string;
+    kind: "cron";
+    staggerMs?: number;
+    tz?: string;
+};
+interface OpenClawCronJob {
+    agentId: string;
+    createdAtMs: number;
+    deleteAfterRun: boolean;
+    delivery: {
+        mode: "none";
+    };
+    enabled: boolean;
+    failureAlert: false;
+    id: string;
+    name: string;
+    payload: {
+        deliver: false;
+        kind: "agentTurn";
+        lightContext: true;
+        message: string;
+    };
+    schedule: OpenClawCronSchedule;
+    sessionTarget: "isolated";
+    state: Record<string, never>;
+    updatedAtMs: number;
+    wakeMode: "now";
+}
+export declare const createOpenClawMemoryDreamJobs: (node: ResolvedAgentNode) => OpenClawCronJob[];
+export declare const createOpenClawCronStoreFile: (node: ResolvedAgentNode) => EmittedFile | null;
+export {};

package/dist/runtime/openclaw/schedules.js

@@ -0,0 +1,74 @@
+import { slugify } from "../../compiler/helpers.js";
+import { isMnemeMemoryAccessSupported, mnemeMemoryServerName } from "../mnemeMcp.js";
+import { parseEveryScheduleMs } from "../scheduleUtils.js";
+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 { anchorMs: 0, everyMs, kind: "every" };
+    }
+    return { expr: schedule, kind: "cron", staggerMs: 0 };
+};
+export const createOpenClawMemoryDreamJobs = (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({
+            agentId: "main",
+            createdAtMs: 0,
+            deleteAfterRun: false,
+            delivery: { mode: "none" },
+            enabled: true,
+            failureAlert: false,
+            id,
+            name: id,
+            payload: {
+                deliver: false,
+                kind: "agentTurn",
+                lightContext: true,
+                message: dreamPrompt(access.bank.id, dreamServerName)
+            },
+            schedule: scheduleFromMemoryConsolidation(schedule),
+            sessionTarget: "isolated",
+            state: {},
+            updatedAtMs: 0,
+            wakeMode: "now"
+        });
+    }
+    return jobs;
+};
+export const createOpenClawCronStoreFile = (node) => {
+    const jobs = createOpenClawMemoryDreamJobs(node);
+    if (jobs.length === 0) {
+        return null;
+    }
+    const store = {
+        jobs,
+        version: 1
+    };
+    return {
+        content: `${JSON.stringify(store, null, 2)}\n`,
+        path: "home/.openclaw/cron/jobs.json"
+    };
+};

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

@@ -1,4 +1,4 @@
 import type { RuntimeAdapter } from "../types.js";
 export declare const piAdapter: RuntimeAdapter;
 export declare const daimonAdapter: RuntimeAdapter;
-export declare const PI_RUNTIME_PACKAGE = "@earendil-works/pi-coding-agent@0.79.9";
+export declare const PI_RUNTIME_PACKAGE = "@earendil-works/pi-coding-agent@0.79.10";

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 { 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,18 +166,58 @@ export const piAdapter = {
             ],
             files: [
                 ...createDocumentFiles("workspace", node.docs),
-                ...createSkillFiles("workspace/skills", node.skills)
+                ...createSkillFiles("workspace/skills", 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`));
         }