spawnfile 0.1.13 → 0.1.17

package/dist/runtime/localDaimonAuthority.js

@@ -0,0 +1,77 @@
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { SpawnfileError } from "../shared/index.js";
+import { DAIMON_CONTRACT_MANIFEST_SHA256 } from "./daimon/contractManifest.js";
+export const DAIMON_LOCAL_RUNTIME_IDENTITY_ENV = "SPAWNFILE_DAIMON_LOCAL_RUNTIME_IDENTITY";
+const LOCAL_DAIMON_REPOSITORY_PATH = "noopolis/spawnfile-runtime-daimon";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const MAX_IDENTITY_BYTES = 16 * 1024;
+const localDaimonRuntimeIdentitySchema = z
+    .object({
+    capability_receipt_sha256: z.string().regex(DIGEST),
+    development: z
+        .object({
+        mode: z.literal("local-development"),
+        non_production: z.literal(true),
+        unpublished: z.literal(true),
+        unsigned: z.literal(true)
+    })
+        .strict(),
+    image_architecture: z.union([z.literal("amd64"), z.literal("arm64")]),
+    image_config_digest: z.string().regex(DIGEST),
+    image_manifest_digest: z.string().regex(DIGEST),
+    image_reference: z.string(),
+    manifest_sha256: z.string().regex(DIGEST),
+    registry_authority: z.string().regex(/^127\.0\.0\.1:(?:[1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/u),
+    version: z.literal("spawnfile.local-daimon-runtime-identity.v3")
+})
+    .strict()
+    .superRefine((identity, context) => {
+    const expected = `${identity.registry_authority}/${LOCAL_DAIMON_REPOSITORY_PATH}@${identity.image_manifest_digest}`;
+    if (identity.image_reference !== expected) {
+        context.addIssue({
+            code: "custom",
+            message: "image_reference must bind the approved local registry repository and manifest digest",
+            path: ["image_reference"]
+        });
+    }
+});
+const fail = (message) => {
+    throw new SpawnfileError("runtime_error", message);
+};
+export const loadLocalDaimonRuntimeIdentity = async (identityPath) => {
+    if (!path.isAbsolute(identityPath)) {
+        return fail("Local Daimon runtime identity path must be absolute");
+    }
+    let entry;
+    try {
+        entry = await lstat(identityPath);
+    }
+    catch {
+        return fail("Local Daimon runtime identity is missing or unreadable");
+    }
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.size === 0 || entry.size > MAX_IDENTITY_BYTES) {
+        return fail("Local Daimon runtime identity must be a bounded nonempty regular file");
+    }
+    let value;
+    try {
+        value = JSON.parse(await readFile(identityPath, "utf8"));
+    }
+    catch {
+        return fail("Local Daimon runtime identity must contain valid JSON");
+    }
+    const parsed = localDaimonRuntimeIdentitySchema.safeParse(value);
+    if (!parsed.success || parsed.data.manifest_sha256 !== DAIMON_CONTRACT_MANIFEST_SHA256) {
+        return fail("Local Daimon runtime identity is invalid or incomplete");
+    }
+    return Object.freeze({
+        capabilityReceipt: parsed.data.capability_receipt_sha256,
+        imageArchitecture: parsed.data.image_architecture,
+        imageConfigDigest: parsed.data.image_config_digest,
+        imageManifestDigest: parsed.data.image_manifest_digest,
+        imageReference: parsed.data.image_reference,
+        manifestSha256: parsed.data.manifest_sha256,
+        registryAuthority: parsed.data.registry_authority
+    });
+};

package/dist/runtime/mnemeMcp.d.ts

@@ -0,0 +1,28 @@
+import type { ResolvedAgentNode } from "../compiler/types.js";
+export declare const MNEME_PACKAGE = "@noopolis/mneme@0.1.1";
+type MnemeMcpMode = "awake" | "dream";
+type MnemeMemoryAccess = NonNullable<ResolvedAgentNode["memoryAccess"]>[number];
+interface MnemeMcpServerOptions {
+    modes?: MnemeMcpMode[];
+}
+export declare const resolveMnemeMemoryRuntimeHomePath: (access: MnemeMemoryAccess) => string | null;
+export declare const isMnemeMemoryAccessSupported: (access: MnemeMemoryAccess) => boolean;
+/**
+ * The container path a bank's Mneme runtime home is durably mounted at, or
+ * `null` when the compiler emits no persistent volume for it.
+ *
+ * This is the single authority shared by two sides that must never disagree:
+ * `src/compiler/memoryArtifacts.ts`, which emits the persistent mount (and
+ * therefore the directory the Daimon UID entrypoint creates and chowns to the
+ * runtime uid), and the runtime config emitters, which may only point an
+ * in-process Mneme runtime at a path the container actually mounts. A path
+ * without a mount is either absent at runtime or root-owned, so an in-process
+ * runtime pointed at one fails its first `mkdir`/write instead of degrading.
+ */
+export declare const resolveMnemeDurableMemoryMountPath: (bank: MnemeMemoryAccess["bank"]) => string | null;
+export declare const mnemeMemoryServerBaseName: (node: ResolvedAgentNode, access: MnemeMemoryAccess) => string;
+export declare const mnemeMemoryServerName: (node: ResolvedAgentNode, access: MnemeMemoryAccess, mode: MnemeMcpMode) => string;
+export declare const buildMnemeMemoryMcpServers: (node: ResolvedAgentNode, options?: MnemeMcpServerOptions) => Record<string, Record<string, unknown>>;
+export declare const hasScheduledMemoryConsolidation: (node: ResolvedAgentNode) => boolean;
+export declare const hasUnsupportedMnemeMemoryAccess: (node: ResolvedAgentNode) => boolean;
+export {};

package/dist/runtime/mnemeMcp.js

@@ -0,0 +1,135 @@
+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 normalizePosixPath = (value) => path.normalize(value).replace(/\/+$/u, "") || "/";
+/**
+ * The container path a bank's Mneme runtime home is durably mounted at, or
+ * `null` when the compiler emits no persistent volume for it.
+ *
+ * This is the single authority shared by two sides that must never disagree:
+ * `src/compiler/memoryArtifacts.ts`, which emits the persistent mount (and
+ * therefore the directory the Daimon UID entrypoint creates and chowns to the
+ * runtime uid), and the runtime config emitters, which may only point an
+ * in-process Mneme runtime at a path the container actually mounts. A path
+ * without a mount is either absent at runtime or root-owned, so an in-process
+ * runtime pointed at one fails its first `mkdir`/write instead of degrading.
+ */
+export const resolveMnemeDurableMemoryMountPath = (bank) => {
+    const store = bank.store;
+    if (store.kind !== "sqlite" && store.kind !== "json") {
+        return null;
+    }
+    if (store.persistence?.mode === "ephemeral") {
+        return null;
+    }
+    if (store.persistence?.mount) {
+        return normalizePosixPath(store.persistence.mount);
+    }
+    return store.path ? path.dirname(normalizePosixPath(store.path)) : 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

@@ -1,11 +1,14 @@
 import { listEffectiveExecutionModelTargets } from "../../compiler/modelEnv.js";
-import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles } from "../common.js";
+import { createAgentCapabilities, createDiagnostic, createDocumentFiles, createSkillFiles, WORKSPACE_SKILL_BASE_DIRECTORY } from "../common.js";
 import { SpawnfileError } from "../../shared/index.js";
 import { applyOpenClawImportAuthConfig, resolveOpenClawImportAuthModes } from "./configAuth.js";
 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),
+                ...createSkillFiles(WORKSPACE_SKILL_BASE_DIRECTORY, 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,3 @@
 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";