@themoltnet/pi-extension 0.16.1 → 0.17.0

package/README.md

@@ -140,6 +140,7 @@ the base snapshot is used (Alpine + git + gh + MoltNet CLI + agent user).
     "cpus": 2,
     "memory": "6G"
   },
+  "resumeCommands": ["corepack enable"],
   "snapshot": {
     "allowedHosts": ["unofficial-builds.nodejs.org"],
     "overlaySize": "8G",
@@ -175,6 +176,25 @@ VM resource limits applied at runtime.
 | `cpus`   | Number of virtual CPUs  |
 | `memory` | RAM limit (e.g. `"6G"`) |
 
+### `resumeCommands`
+
+Shell commands that run on every VM resume, after platform setup and before the
+agent session starts.
+
+Use this for per-session bootstrap that should not invalidate the snapshot
+cache: mounting tmpfs, warming package-manager state, lightweight repo-local
+setup.
+
+Important properties:
+
+- runs after TLS, DNS, and `git safe.directory` setup
+- not part of the snapshot cache key
+- each command runs in a fresh shell with `set -eu` and `set -o pipefail`
+- first non-zero exit aborts VM resume
+
+This split exists so repo-specific bootstrap can live in `sandbox.json` while
+`pi-extension` stays consumer-agnostic.
+
 ### `vfs`
 
 VFS shadow configuration — hide host paths from the guest mount.
@@ -187,6 +207,31 @@ VFS shadow configuration — hide host paths from the guest mount.
 Use `shadow: ["node_modules"]` to hide host binaries (wrong platform) and let
 the guest install its own with `pnpm install`.
 
+#### VFS caveat: shadowing is not a pnpm performance fix
+
+For this repo we hit two distinct `/workspace` problems:
+
+- the FUSE bridge makes file-write-heavy installs much slower than guest-local filesystems
+- the `/workspace` VFS path drops `chmod()` calls, which breaks tools that create files and chmod them later
+
+Dogfood trail:
+
+- `47b67636-067a-4254-9098-38d00b4867bb` — `/workspace` install path measured at roughly 80x slower than guest tmpfs
+- `62082ec9-0554-4bdc-9c64-9d89ece3fa40` — `chmod()` gap on the workspace mount
+- `17f0ac6f-07f0-4e12-b5e5-d35a0fa2df6c` — first 100x pnpm recipe
+- `2e4e25a9-ef4b-46bf-a55d-6c2b1159ee61` — follow-up fix for per-workspace `node_modules`
+
+`vfs.shadow: ["node_modules"]` is still useful to hide host-built artifacts,
+but it does not solve the hot-path problem by itself. For fast pnpm setup, move
+both endpoints off the FUSE bridge:
+
+- package store on guest-local disk, e.g. `NPM_CONFIG_STORE_DIR=/opt/pnpm-store`
+- install target on guest tmpfs via `resumeCommands`
+
+Current themoltnet `sandbox.json` does this by mounting tmpfs over the root and
+per-workspace `node_modules` directories before running `pnpm install
+--frozen-lockfile`.
+
 ### `env`
 
 Environment variable overrides applied to the guest VM. Use this to fix host

package/dist/index.d.ts

@@ -32,9 +32,11 @@ import { WriteOperations } from '@earendil-works/pi-coding-agent';
 export declare function activateAgentEnv(agentEnv: Record<string, string | undefined>, repoRoot: string): void;
 
 /**
- * Construct an in-memory `AgentSession`. The caller is responsible for
- * eventually invoking `session.prompt(...)` and for tearing down — the
- * helper does no lifecycle management beyond construction.
+ * Construct an `AgentSession`. By default it is in-memory; callers may opt
+ * parent sessions into daemon-owned file persistence via `sessionPersistence`.
+ * The caller is responsible for eventually invoking `session.prompt(...)` and
+ * for tearing down — the helper does no lifecycle management beyond
+ * construction.
  */
 export declare function buildAgentSession(args: BuildAgentSessionArgs): Promise<AgentSession>;
 
@@ -56,6 +58,13 @@ declare interface BuildAgentSessionArgs {
     otelSpanAttrs: Record<string, string | number | boolean>;
     /** Agent name for `gen_ai.agent.name` on the root span. */
     agentName: string;
+    /**
+     * Parent sessions may persist their conversation history in a daemon-owned
+     * directory. Subagents should leave this unset and stay in-memory.
+     */
+    sessionPersistence?: {
+        sessionDir: string;
+    };
 }
 
 declare interface ClaimedTask {
@@ -277,6 +286,12 @@ export declare interface ExecutePiTaskOptions {
      * after HOST_EXEC_ALLOWED; an array limits auto-approval to matching rules.
      */
     hostExecAutoApprove?: HostExecAutoApproveConfig;
+    /**
+     * Optional daemon-supplied execution plan. Keeps task semantics out of
+     * `pi-extension` while still letting callers opt into stable worktrees and
+     * file-backed Pi sessions for selected task classes.
+     */
+    makeExecutionPlan?: PiTaskExecutionPlanFactory;
 }
 
 /**
@@ -415,6 +430,42 @@ export declare interface PiOtelOptions {
     spanAttributes?: Record<string, string | number | boolean>;
 }
 
+export declare interface PiSessionPersistencePlan {
+    sessionDir: string;
+}
+
+export declare interface PiTaskExecutionPlan {
+    /**
+     * Daemon-local reuse key. When set alongside `workspaceScope: 'session'`,
+     * dedicated worktrees may be retained and reopened across related tasks.
+     */
+    sessionKey: string | null;
+    /**
+     * Workspace identity selected by the daemon. `null` means the task should
+     * run against the shared mount path.
+     */
+    workspaceId: string | null;
+    /**
+     * Branch to create or reopen for the workspace. `null` means no dedicated
+     * worktree is required.
+     */
+    worktreeBranch: string | null;
+    /**
+     * Lifetime of the task workspace from the daemon's point of view.
+     * `attempt` = disposable; `session` = keep stable for the reuse key.
+     */
+    workspaceScope: 'attempt' | 'session';
+    /**
+     * Optional location for file-backed Pi session history. When omitted,
+     * the executor keeps the conversation in memory for this attempt only.
+     */
+    sessionPersistence?: PiSessionPersistencePlan | null;
+}
+
+export declare type PiTaskExecutionPlanFactory = (claimedTask: ClaimedTask) => PiTaskExecutionPlan | null;
+
+export declare function resolveTaskWorktreePath(mainRepo: string, workspaceId: string): string;
+
 /**
  * Resume a VM from a checkpoint, inject credentials, configure egress +
  * TLS. Returns the managed VM handle.

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
-import path, { join } from "node:path";
+import path, { join, relative } from "node:path";
 import { DefaultResourceLoader, SessionManager, createAgentSession, createBashTool, createBashToolDefinition, createEditTool, createEditToolDefinition, createReadTool, createReadToolDefinition, createSyntheticSourceInfo, createWriteTool, createWriteToolDefinition, defineTool, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
@@ -8633,9 +8633,11 @@ var NO_SKILLS = () => ({
 	diagnostics: []
 });
 /**
-* Construct an in-memory `AgentSession`. The caller is responsible for
-* eventually invoking `session.prompt(...)` and for tearing down — the
-* helper does no lifecycle management beyond construction.
+* Construct an `AgentSession`. By default it is in-memory; callers may opt
+* parent sessions into daemon-owned file persistence via `sessionPersistence`.
+* The caller is responsible for eventually invoking `session.prompt(...)` and
+* for tearing down — the helper does no lifecycle management beyond
+* construction.
 */
 async function buildAgentSession(args) {
 	const piOtelExtension = createPiOtelExtension({
@@ -8650,15 +8652,23 @@ async function buildAgentSession(args) {
 		skillsOverride: args.skillsOverride ?? NO_SKILLS
 	});
 	await resourceLoader.reload();
+	const sessionManager = args.sessionPersistence ? await resolvePersistentSessionManager({
+		cwd: args.mountPath,
+		sessionDir: args.sessionPersistence.sessionDir
+	}) : SessionManager.inMemory(args.mountPath);
 	return (await createAgentSession({
 		agentDir: args.piAuthDir,
 		cwd: args.mountPath,
 		model: args.modelHandle,
 		customTools: args.customTools,
-		sessionManager: SessionManager.inMemory(),
+		sessionManager,
 		resourceLoader
 	})).session;
 }
+async function resolvePersistentSessionManager(args) {
+	await SessionManager.list(args.cwd, args.sessionDir);
+	return SessionManager.continueRecent(args.cwd, args.sessionDir);
+}
 //#endregion
 //#region ../tasks/src/formats.ts
 /**
@@ -8824,22 +8834,6 @@ function validateRubricWeights(rubric) {
 	if (Math.abs(sum - 1) > 1e-6) return `Rubric weights must sum to 1.0 (got ${sum.toFixed(6)})`;
 	return null;
 }
-`
-You are reviewing a GitHub pull request for **complexity** — how hard
-this change is to review safely, NOT whether it's correct or whether
-the feature is worthwhile. The diff has already been opened by the
-producer; your job is to score reviewability.
-
-You may run \`gh pr diff <number>\`, \`gh pr view <number>\`, and read
-files in the workspace. Don't run tests, don't push commits, don't
-modify anything. The PR's GitHub URL is in the target metadata.
-
-When in doubt about a criterion, score conservatively (lower) and
-explain what made the call ambiguous. Reviewers will read your
-rationale; "looks fine" is not useful, "the change touches three
-unrelated subsystems and the test coverage on the auth path is
-unchanged" is.
-`.trim();
 //#endregion
 //#region ../tasks/src/success-criteria.ts
 /**
@@ -9718,6 +9712,10 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: FulfillBriefInput,
 		outputSchema: FulfillBriefOutput,
 		outputKind: "artifact",
+		resumable: true,
+		workspaceMode: "dedicated_worktree",
+		workspaceScope: "session",
+		sessionScope: "correlation",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -9726,6 +9724,9 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: AssessBriefInput,
 		outputSchema: AssessBriefOutput,
 		outputKind: "judgment",
+		workspaceMode: "dedicated_worktree",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateInputAsync: validateAssessBriefInputAsync
@@ -9735,6 +9736,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: CuratePackInput,
 		outputSchema: CuratePackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent
 	},
@@ -9743,6 +9746,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RenderPackInput,
 		outputSchema: RenderPackOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: false,
 		validateOutput: requireVerificationWhenCriteriaPresent,
 		validateInputAsync: validateRenderPackInputAsync
@@ -9752,6 +9757,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgePackInput,
 		outputSchema: JudgePackOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "none",
 		requiresReferences: true,
 		validateInput: validateJudgmentInput,
 		validateOutput: validateJudgePackOutput,
@@ -9762,6 +9769,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: RunEvalInput,
 		outputSchema: RunEvalOutput,
 		outputKind: "artifact",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateOutput: validateRunEvalOutput
 	},
@@ -9770,6 +9779,8 @@ var BUILT_IN_TASK_TYPES = {
 		inputSchema: JudgeEvalVariantInput,
 		outputSchema: JudgeEvalVariantOutput,
 		outputKind: "judgment",
+		workspaceScope: "attempt",
+		sessionScope: "custom",
 		requiresReferences: false,
 		validateInput: validateJudgeEvalVariantInput,
 		validateOutput: validateJudgeEvalVariantOutput,
@@ -10326,6 +10337,15 @@ function buildAssessBriefUserPrompt(input, ctx) {
 		rubric.preamble,
 		""
 	].join("\n") : "";
+	const workspaceSection = ctx.workspace?.mode === "dedicated_worktree" ? [
+		"### Workspace",
+		"",
+		"This review attempt is running inside a dedicated disposable git",
+		"worktree created for this task. If you need to check out the target",
+		"branch or inspect refs locally, do it only inside this worktree.",
+		ctx.workspace.branch ? `The current review branch is \`${ctx.workspace.branch}\`. You may replace it with the target branch locally if that helps your inspection.` : "The current checkout is disposable and will be cleaned up when the task ends.",
+		""
+	].join("\n") : "";
 	return [
 		"# Assess Brief Judge",
 		"",
@@ -10366,6 +10386,7 @@ function buildAssessBriefUserPrompt(input, ctx) {
 		"  read it from the task you fetched in step 1 and pass",
 		"  `taskFilter: { correlationId: \"<id>\" }`.",
 		"",
+		workspaceSection,
 		preambleSection,
 		"## Criteria",
 		"",
@@ -10625,6 +10646,14 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 		"from this branch naming scheme when correlationId is set.",
 		""
 	].join("\n") : "";
+	const workspaceSection = ctx.workspace?.mode === "dedicated_worktree" ? [
+		"### Workspace",
+		"",
+		"This attempt is running inside a dedicated git worktree created",
+		"for this task. Do not repurpose or switch the primary checkout.",
+		ctx.workspace.branch ? `The current branch is \`${ctx.workspace.branch}\`. Stay on this branch unless the runtime instructor explicitly tells you otherwise.` : "Stay on the branch that was pre-provisioned for this task.",
+		""
+	].join("\n") : "";
 	return [
 		"# Fulfill Brief Agent",
 		"",
@@ -10645,9 +10674,10 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 		criteriaSection,
 		seedSection,
 		correlationSection,
+		workspaceSection,
 		"### Workflow",
 		"",
-		`1. Create a feature branch (starting prefix suggestion: \`${branchSlug}<short-slug>\`).`,
+		ctx.workspace?.mode === "dedicated_worktree" ? `1. Use the already-provisioned dedicated worktree branch${ctx.workspace.branch ? ` (\`${ctx.workspace.branch}\`)` : ""}; do not create or switch the primary checkout.` : `1. Create a feature branch (starting prefix suggestion: \`${branchSlug}<short-slug>\`).`,
 		"2. Understand the problem — read relevant code; do not speculate.",
 		"3. Implement the change. Keep commits small and coherent.",
 		"4. Add tests if applicable.",
@@ -11045,7 +11075,8 @@ function buildTaskUserPrompt(task, ctx) {
 			return buildFulfillBriefUserPrompt(task.input, {
 				diaryId: ctx.diaryId,
 				taskId: ctx.taskId,
-				correlationId: task.correlationId
+				correlationId: task.correlationId,
+				workspace: ctx.workspace
 			});
 		case ASSESS_BRIEF_TYPE:
 			if (!Value.Check(AssessBriefInput, task.input)) {
@@ -11054,7 +11085,8 @@ function buildTaskUserPrompt(task, ctx) {
 			}
 			return buildAssessBriefUserPrompt(task.input, {
 				diaryId: ctx.diaryId,
-				taskId: ctx.taskId
+				taskId: ctx.taskId,
+				workspace: ctx.workspace
 			});
 		case CURATE_PACK_TYPE:
 			if (!Value.Check(CuratePackInput, task.input)) {
@@ -15182,6 +15214,113 @@ function resolveSubmitTools(taskType, opts = {}) {
 	};
 }
 //#endregion
+//#region src/runtime/task-workspace.ts
+function prepareTaskWorkspace(task, requestedMountPath, executionPlan) {
+	const branch = executionPlan?.worktreeBranch ?? null;
+	if (!branch) return {
+		mountPath: requestedMountPath,
+		mode: "shared_mount",
+		branch: null,
+		cleanup: () => {}
+	};
+	const mainRepo = findMainWorktree();
+	const worktreeDir = resolveTaskWorktreePath(mainRepo, executionPlan?.workspaceId ?? `task-${task.id}`);
+	const relMount = relative(mainRepo, requestedMountPath);
+	const mountPath = relMount === "" || relMount.startsWith("..") ? worktreeDir : join(worktreeDir, relMount);
+	const keepWorkspace = executionPlan?.workspaceScope === "session" && executionPlan.sessionKey !== null;
+	if (keepWorkspace) ensureReusableTaskWorktree(mainRepo, worktreeDir, branch);
+	else {
+		removeExistingTaskWorktree(mainRepo, worktreeDir);
+		addTaskWorktree(mainRepo, worktreeDir, branch);
+	}
+	return {
+		mountPath,
+		mode: "dedicated_worktree",
+		branch,
+		cleanup: keepWorkspace ? () => {} : () => {
+			execFileSync("git", [
+				"-C",
+				mainRepo,
+				"worktree",
+				"remove",
+				"--force",
+				worktreeDir
+			], { stdio: "pipe" });
+		}
+	};
+}
+function resolveTaskWorktreePath(mainRepo, workspaceId) {
+	return join(mainRepo, ".worktrees", workspaceId);
+}
+function ensureReusableTaskWorktree(mainRepo, worktreeDir, branch) {
+	if (isRegisteredWorktree(mainRepo, worktreeDir)) return;
+	if (existsSync(worktreeDir)) throw new Error(`Expected reusable worktree ${worktreeDir} to be git-managed, but it exists outside git worktree metadata.`);
+	addTaskWorktree(mainRepo, worktreeDir, branch);
+}
+function addTaskWorktree(mainRepo, worktreeDir, branch) {
+	const baseRef = resolveWorktreeBaseRef(mainRepo);
+	execFileSync("git", gitRefExists(mainRepo, `refs/heads/${branch}`) ? [
+		"-C",
+		mainRepo,
+		"worktree",
+		"add",
+		worktreeDir,
+		branch
+	] : [
+		"-C",
+		mainRepo,
+		"worktree",
+		"add",
+		"-b",
+		branch,
+		worktreeDir,
+		baseRef
+	], { stdio: "pipe" });
+}
+function removeExistingTaskWorktree(mainRepo, worktreeDir) {
+	if (!existsSync(worktreeDir) || !isRegisteredWorktree(mainRepo, worktreeDir)) return;
+	execFileSync("git", [
+		"-C",
+		mainRepo,
+		"worktree",
+		"remove",
+		"--force",
+		worktreeDir
+	], { stdio: "pipe" });
+}
+function isRegisteredWorktree(mainRepo, worktreeDir) {
+	const list = execFileSync("git", [
+		"-C",
+		mainRepo,
+		"worktree",
+		"list",
+		"--porcelain"
+	], {
+		encoding: "utf8",
+		stdio: "pipe"
+	});
+	const marker = `worktree ${worktreeDir}\n`;
+	return list.includes(marker) || list.endsWith(`worktree ${worktreeDir}`);
+}
+function resolveWorktreeBaseRef(mainRepo) {
+	return gitRefExists(mainRepo, "refs/heads/main") ? "main" : "HEAD";
+}
+function gitRefExists(mainRepo, ref) {
+	try {
+		execFileSync("git", [
+			"-C",
+			mainRepo,
+			"show-ref",
+			"--verify",
+			"--quiet",
+			ref
+		], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/runtime/execute-pi-task.ts
 /**
 * executePiTask — run a single Task attempt using pi-coding-agent inside a
@@ -15230,7 +15369,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 	const task = claimedTask.task;
 	const attemptN = claimedTask.attemptN;
 	const startTime = Date.now();
-	const mountPath = opts.mountPath ?? process.cwd();
+	const requestedMountPath = opts.mountPath ?? process.cwd();
+	const executionPlan = opts.makeExecutionPlan?.(claimedTask) ?? null;
+	const workspace = prepareTaskWorkspace(task, requestedMountPath, executionPlan);
+	const mountPath = workspace.mountPath;
 	if (reporter.cancelSignal.aborted) return {
 		taskId: task.id,
 		attemptN,
@@ -15261,7 +15403,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 			"--relative-paths"
 		], { stdio: "pipe" });
 	} catch {}
-	const managed = await resumeVm({
+	let managed = null;
+	managed = await resumeVm({
 		checkpointPath,
 		agentName: opts.agentName,
 		mountPath,
@@ -15321,13 +15464,19 @@ async function executePiTask(claimedTask, reporter, opts) {
 			taskType: task.taskType,
 			teamId: task.teamId,
 			provider: opts.provider,
-			model: opts.model
+			model: opts.model,
+			workspaceMode: workspace.mode,
+			workspaceBranch: workspace.branch
 		});
 		let taskPrompt;
 		try {
 			taskPrompt = buildTaskUserPrompt(task, {
 				diaryId,
 				taskId: task.id,
+				workspace: {
+					mode: workspace.mode,
+					branch: workspace.branch
+				},
 				extras: opts.promptExtras
 			});
 		} catch (err) {
@@ -15438,7 +15587,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 					"moltnet.task.id": task.id,
 					"moltnet.task.attempt": attemptN,
 					"moltnet.task.type": task.taskType
-				}
+				},
+				sessionPersistence: executionPlan?.sessionPersistence ?? void 0
 			});
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
@@ -15657,7 +15807,13 @@ async function executePiTask(claimedTask, reporter, opts) {
 				console.error(`executePiTask: reporter.close() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
 			}
 		}
-		await managed.vm.close();
+		if (managed) await managed.vm.close();
+		try {
+			workspace.cleanup();
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			console.error(`executePiTask: workspace cleanup failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		}
 	}
 }
 function emptyUsage(provider, model) {
@@ -16039,4 +16195,4 @@ function moltnetExtension(pi) {
 	registerMoltnetReflectCommand(pi, state);
 }
 //#endregion
-export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, resolveTaskWorktreePath, resumeVm, toGuestPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "license": "MIT",
@@ -31,8 +31,8 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "@sinclair/typebox": "^0.34.0",
-    "@themoltnet/agent-runtime": "0.15.0",
-    "@themoltnet/sdk": "0.102.0"
+    "@themoltnet/sdk": "0.102.0",
+    "@themoltnet/agent-runtime": "0.15.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",
@@ -51,7 +51,7 @@
     "@earendil-works/pi-coding-agent": "^0.74.0",
     "@opentelemetry/sdk-metrics": "^2.5.1",
     "@opentelemetry/sdk-trace-base": "^2.5.1",
-    "@types/node": "^20.11.0",
+    "@types/node": "^22.19.0",
     "typescript": "^5.3.3",
     "vite": "^8.0.0",
     "vite-plugin-dts": "^4.5.4",