spawnfile 0.1.13 → 0.1.14

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;

package/dist/runtime/pi/appCliEnginesSource.js

@@ -0,0 +1,183 @@
+export const renderPiCliEnginesSource = () => String.raw `const runCodexEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "codex-home");
+  await mkdir(path.join(engineHomePath, ".codex"), { recursive: true });
+  try {
+    const authSource = path.join(paths.homePath, ".codex", "auth.json");
+    const authTarget = path.join(engineHomePath, ".codex", "auth.json");
+    await writeFile(authTarget, await readFile(authSource, "utf8"));
+  } catch {}
+  const outputPath = path.join(paths.runtimeHomePath, "codex-" + Date.now() + ".txt");
+  const args = [
+    "exec",
+    "--sandbox",
+    process.env.SPAWNFILE_CODEX_SANDBOX ?? "danger-full-access",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "--ignore-rules",
+    "--color",
+    "never",
+    "-C",
+    paths.workspacePath,
+    "--output-last-message",
+    outputPath,
+    "-m",
+    process.env.DAIMON_CODEX_MODEL ?? "gpt-5.4-mini",
+    "-"
+  ];
+  const { stderr, stdout } = await spawnWithInput("codex", args, prompt, {
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath)
+  });
+  try {
+    return stripAnsi(await readFile(outputPath, "utf8"));
+  } catch {
+    return stripAnsi([stdout, stderr].filter(Boolean).join("\n"));
+  }
+};
+
+const runClaudeEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "claude-home");
+  await mkdir(path.join(engineHomePath, ".claude"), { recursive: true });
+  await copyDirectoryIfExists(path.join(paths.homePath, ".claude"), path.join(engineHomePath, ".claude"));
+  await copyDirectoryIfExists(path.join(paths.homePath, ".claude.json"), path.join(engineHomePath, ".claude.json"));
+  const env = process.env.DAIMON_CLAUDE_USE_HOST_HOME === "1"
+    ? process.env
+    : createEngineEnv(paths, engineHomePath);
+  const output = await spawnWithInput("claude", [
+    "--print",
+    "--output-format",
+    "text",
+    "--no-session-persistence",
+    "--permission-mode",
+    process.env.DAIMON_CLAUDE_PERMISSION_MODE ?? "bypassPermissions",
+    "--model",
+    process.env.DAIMON_CLAUDE_MODEL ?? "sonnet",
+    "--add-dir",
+    paths.workspacePath
+  ], prompt, {
+    cwd: paths.workspacePath,
+    env
+  });
+  return cleanCliFinalText(output.stdout);
+};
+
+const runGrokEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "grok-home");
+  await mkdir(engineHomePath, { recursive: true });
+  const sharedGrok = await getSharedGrokHome(paths);
+  const promptPath = path.join(paths.runtimeHomePath, "grok-prompt-" + Date.now() + ".txt");
+  await writeFile(promptPath, prompt);
+  const output = await execFileAsync("grok", [
+    "--prompt-file",
+    promptPath,
+    "--max-turns",
+    process.env.DAIMON_GROK_MAX_TURNS ?? "24",
+    "--no-memory",
+    "--disable-web-search",
+    "--model",
+    process.env.DAIMON_GROK_MODEL ?? "grok-composer-2.5-fast",
+    "--cwd",
+    paths.workspacePath,
+    "--output-format",
+    "plain",
+    "--always-approve",
+    "--permission-mode",
+    process.env.DAIMON_GROK_PERMISSION_MODE ?? "auto",
+    "--allow",
+    "Bash"
+  ], {
+    ...cliOutputOptions,
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath, {
+      GROK_HOME: sharedGrok.grokHomePath
+    })
+  });
+  await unlink(promptPath).catch(() => undefined);
+  return cleanCliFinalText(output.stdout);
+};
+
+const runAgyEngine = async (prompt, paths) => {
+  const engineHomePath = path.join(paths.runtimeHomePath, "agy-home");
+  await mkdir(engineHomePath, { recursive: true });
+  await copyDirectoryIfExists(
+    path.join(paths.homePath, ".config", "Antigravity"),
+    path.join(engineHomePath, ".config", "Antigravity")
+  );
+  await copyDirectoryIfExists(
+    path.join(paths.homePath, ".gemini", "antigravity-cli"),
+    path.join(engineHomePath, ".gemini", "antigravity-cli")
+  );
+  const outputPath = path.join(paths.runtimeHomePath, "agy-output-" + Date.now() + ".txt");
+  const errorPath = path.join(paths.runtimeHomePath, "agy-error-" + Date.now() + ".txt");
+  await spawnToFiles("agy", [
+    "--print",
+    prompt,
+    "--print-timeout",
+    process.env.DAIMON_AGY_TIMEOUT ?? "300s",
+    "--model",
+    process.env.DAIMON_AGY_MODEL ?? "Gemini 3.5 Flash (Low)",
+    "--new-project",
+    "--add-dir",
+    paths.workspacePath,
+    "--dangerously-skip-permissions"
+  ], {
+    cwd: paths.workspacePath,
+    env: createEngineEnv(paths, engineHomePath),
+    stderrPath: errorPath,
+    stdoutPath: outputPath
+  });
+  const text = cleanCliFinalText(await readBounded(outputPath));
+  await Promise.all([unlink(outputPath), unlink(errorPath)].map((promise) => promise.catch(() => undefined)));
+  return text;
+};
+
+const runScriptedEngine = async (config, prompt, paths) => {
+  if (typeof config?.engine_command !== "string" || config.engine_command.length === 0) {
+    throw new Error("Scripted Pi engine is missing its staged engine_command path");
+  }
+  const scriptPath = path.join(paths.workspacePath, config.engine_command);
+  await mkdir(paths.runtimeHomePath, { recursive: true });
+  const promptPath = path.join(paths.runtimeHomePath, "scripted-prompt-" + Date.now() + ".txt");
+  await writeFile(promptPath, prompt);
+  const args = ["--prompt-file", promptPath, "--cwd", paths.workspacePath];
+  let output;
+  try {
+    output = await execFileAsync("node", [scriptPath, ...args], {
+      ...cliOutputOptions,
+      cwd: paths.workspacePath,
+      env: process.env
+    });
+  } finally {
+    await unlink(promptPath).catch(() => undefined);
+  }
+  appendFileSync(
+    path.join(paths.runtimeHomePath, "scripted-engine-calls.jsonl"),
+    JSON.stringify({
+      args,
+      script: scriptPath,
+      timestamp: new Date().toISOString()
+    }) + "\n"
+  );
+  return output.stdout.trim();
+};
+
+const runCliEngine = async (engine, prompt, paths, config) => {
+  const startedAt = Date.now();
+  let text;
+  if (engine === "codex") {
+    text = await runCodexEngine(prompt, paths);
+  } else if (engine === "claude") {
+    text = await runClaudeEngine(prompt, paths);
+  } else if (engine === "grok") {
+    text = await runGrokEngine(prompt, paths);
+  } else if (engine === "scripted") {
+    text = await runScriptedEngine(config, prompt, paths);
+  } else {
+    text = await runAgyEngine(prompt, paths);
+  }
+  return {
+    durationMs: Date.now() - startedAt,
+    text
+  };
+};
+`;

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

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