@parcha/agentrun-pi 0.1.0-beta.23 → 0.1.0-beta.26

package/dist/durable/index.d.ts

@@ -1,6 +1,6 @@
 export type { RecoveryBinding, RecoveryEffect, RecoveryJournal, RecoveryNote, RecoveryStore } from "@parcha/agentrun-dsl/recovery";
 export { documentStore, type DocumentStoreHost, type DocumentStoreOptions } from "./store.js";
-export { committedRoutes, durableDecisions, durableDoc, readJournal, type JournalView } from "./readers.js";
+export { committedRoutes, durableDecisions, durableDoc, readJournal, type DurableReadOptions, type JournalView } from "./readers.js";
 export { recordCommits, recordingLines, snapshotLines, type RecordingLine, type RecordingSource } from "./recording.js";
 export { reuseReceipts, seedReceipts, ReceiptIndex, type ReceiptReuse, type ReuseReceiptsOptions, type ReusableTool } from "./receipts.js";
 export { effectResultOf } from "../effect-result.js";

package/dist/durable/node-runner.js

@@ -12,6 +12,7 @@
 import { randomUUID } from "node:crypto";
 import { configure, defineDoc, defineExtension, GenerationTask, hook, section, } from "@earendil-works/pi-durable";
 import { canonicalSha256, runStopOf } from "@parcha/agentrun-dsl/recovery";
+import { SUBMIT_TOOL } from "../host-tools.js";
 import { nodeThinking } from "../thinking.js";
 import { closeNodeAttempt, runNodeAttempt } from "./node.js";
 import { DELIVERY_ATTEMPTS, lintRecordRoot, submitFooter } from "./record.js";
@@ -78,7 +79,7 @@ async function underStop(signal, work) {
     }
 }
 const listed = (value) => Array.isArray(value);
-const isSubmit = (tool) => tool.name === "submit";
+const isSubmit = (tool) => tool.name === SUBMIT_TOOL;
 /** The node runner over a host. Install `extension` in the registry before the Harness opens; `on` binds the runner
  *  to where its conversations live (`taskScope`, `hostScope`). */
 export function nodeRunner(host, options = {}) {
@@ -177,7 +178,7 @@ export function nodeRunner(host, options = {}) {
                 const { agent, record } = await underStop(signal, async () => ({ agent: leveled(await host.agent(node), node), record: await host.record?.(node) ?? {} }));
                 const label = record.label ?? `the ${node.label} record`;
                 const offered = (listed(agent.tools) ? agent.tools : listed(agent.extensions) ? agent.extensions.flatMap((selected) => selected.tools ?? []) : [])
-                    .map((offer) => offer.name).filter((name) => name !== "submit");
+                    .map((offer) => offer.name).filter((name) => name !== SUBMIT_TOOL);
                 const system = [...node.system, host.stance?.(node, { tools: offered })].filter(Boolean).join("\n\n");
                 const input = inputOf(node.user);
                 const reviewers = [

package/dist/durable/readers.d.ts

@@ -11,11 +11,16 @@ export type JournalView = {
     notes: RecoveryNote[];
     effects: RecoveryEffect[];
 };
+/** How a reader opens the store file. `immutable` opens it as SQLite's immutable file, for a store no process writes any
+ *  more and with no write-ahead log beside it (an ended run's): nothing beside it is read or made. */
+export type DurableReadOptions = {
+    immutable?: boolean;
+};
 /** The run's store `file`, opened read-only for `read`; null when there is no such file. Every query of one `read` runs
  *  in one read transaction, so what it returns is one commit's view, whatever a writer commits meanwhile. */
-export declare function withDurableFile<T>(file: string, read: (db: Database) => T): T | null;
+export declare function withDurableFile<T>(file: string, read: (db: Database) => T, options?: DurableReadOptions): T | null;
 /** A Session document of the run's store `file`, read-only; undefined when the file or the document is absent. */
-export declare function durableDoc<T = Record<string, unknown>>(file: string, kind: string, key?: string): T | undefined;
+export declare function durableDoc<T = Record<string, unknown>>(file: string, kind: string, key?: string, options?: DurableReadOptions): T | undefined;
 /** The decision rows (`agentrun.decisions`) of the run's store `file`, in commit order, in whichever form the store holds: the single
  *  document's `receipts` list, or the keyed documents (one row each, in the order of their keys). A reader that folds decisions from the
  *  store uses this and not `durableDoc(file, "agentrun.decisions").receipts`, which is nothing in the keyed form. */
@@ -25,7 +30,7 @@ export declare function durableDecisions(file: string): Array<Record<string, unk
  *  admitted, in either layout: in the keyed one (`agentrun.frozen_run.v4`) the effects a map item owns, nested maps
  *  included, are listed by that item's record, not the driver's, and are read from there. `state` is the driver's own
  *  record: in the keyed layout what lies in each map item stays in the item's record. */
-export declare function readJournal(file: string, key: string): JournalView | undefined;
+export declare function readJournal(file: string, key: string, options?: DurableReadOptions): JournalView | undefined;
 /** Every committed route decision a frozen snapshot holds (each judge's answer, whole), by execution path. Empty for a
  *  state that is no snapshot. */
 export declare function committedRoutes(state: unknown): Record<string, Json>;

package/dist/durable/readers.js

@@ -4,16 +4,17 @@
 // readers take the store file itself (pi-durable's SQLite file, wherever the host keeps it), never a directory.
 import fs from "node:fs";
 import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 import { apply } from "@earendil-works/chord/delta";
 import { decisionKey } from "./decisions.js";
 import { effectKey } from "./store.js";
 /** The run's store `file`, opened read-only for `read`; null when there is no such file. Every query of one `read` runs
  *  in one read transaction, so what it returns is one commit's view, whatever a writer commits meanwhile. */
-export function withDurableFile(file, read) {
+export function withDurableFile(file, read, options = {}) {
     if (!fs.existsSync(file))
         return null;
     const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
-    const db = new DatabaseSync(file, { readOnly: true, timeout: 5000 });
+    const db = new DatabaseSync(options.immutable ? `${pathToFileURL(file).href}?immutable=1` : file, { readOnly: true, timeout: 5000 });
     try {
         db.exec("BEGIN");
         return read(db);
@@ -67,8 +68,8 @@ function itemEffects(db, key, table, into) {
     }
 }
 /** A Session document of the run's store `file`, read-only; undefined when the file or the document is absent. */
-export function durableDoc(file, kind, key) {
-    return (withDurableFile(file, (db) => sessionDoc(db, kind, key)) ?? undefined);
+export function durableDoc(file, kind, key, options = {}) {
+    return (withDurableFile(file, (db) => sessionDoc(db, kind, key), options) ?? undefined);
 }
 /** The decision rows (`agentrun.decisions`) of the run's store `file`, in commit order, in whichever form the store holds: the single
  *  document's `receipts` list, or the keyed documents (one row each, in the order of their keys). A reader that folds decisions from the
@@ -94,7 +95,7 @@ export function durableDecisions(file) {
  *  admitted, in either layout: in the keyed one (`agentrun.frozen_run.v4`) the effects a map item owns, nested maps
  *  included, are listed by that item's record, not the driver's, and are read from there. `state` is the driver's own
  *  record: in the keyed layout what lies in each map item stays in the item's record. */
-export function readJournal(file, key) {
+export function readJournal(file, key, options = {}) {
     return withDurableFile(file, (db) => {
         const doc = sessionDoc(db, "agentrun.driver", key);
         if (!doc || doc.binding === null)
@@ -113,7 +114,7 @@ export function readJournal(file, key) {
             return { id, name: e?.name ?? "", argsHash: e?.argsHash ?? "", status: e?.status ?? "unknown", session: e?.session ?? null, result: e?.result ?? null, ...(e?.intent ? { intent: e.intent } : {}), ...(e?.args !== undefined ? { args: e.args } : {}), ...(Array.isArray(e?.calls) ? { calls: e.calls } : {}) };
         });
         return { binding: doc.binding, inputs: doc.inputs, generation: doc.generation, revision: doc.revision, state: doc.state, notes: doc.notes, effects };
-    }) ?? undefined;
+    }, options) ?? undefined;
 }
 /** Every committed route decision a frozen snapshot holds (each judge's answer, whole), by execution path. Empty for a
  *  state that is no snapshot. */

package/dist/durable/record-tool.js

@@ -1,5 +1,6 @@
 import { defineDoc, defineTool, GenerationTask, hook, } from "@earendil-works/pi-durable";
 import { DELIVERY_ATTEMPTS, deliver, deliveryTerminates, deliveryText, fileSubmission, mixedFileSubmission, nudgeText, repairRecord, VIOLATIONS_SHOWN, } from "./record.js";
+import { SUBMIT_TOOL } from "../host-tools.js";
 import { toolResult } from "./pi-versions.js";
 /** The record a conversation delivered, or null while it has not, and the delivery attempts it has spent. */
 export const RecordDoc = defineDoc({
@@ -76,7 +77,7 @@ export function recordTool(options) {
         ...(deliveryTerminates(delivery) ? { control: { terminate: true } } : {}),
     });
     return defineTool({
-        name: "submit",
+        name: SUBMIT_TOOL,
         description: shown.description,
         parameters: shown.parameters,
         // Every call's arguments are carried to `execute`; one record's are repaired here, before the Harness validates.

package/dist/durable/workflow-tool.js

@@ -8,7 +8,7 @@ import { Type } from "typebox";
 import { inspectWorkflow, WORKFLOW_NODE_KINDS } from "@parcha/agentrun-dsl";
 import { canonicalHash } from "@parcha/agentrun-dsl/recovery";
 import { extensionStructuralLimits, WorkflowExtensionService } from "../extension-service.js";
-import { checkHostTools } from "../host-tools.js";
+import { assertHostTools, SUBMIT_TOOL } from "../host-tools.js";
 import { modelJson } from "../presentation.js";
 import { WorkflowStore } from "../workflow-store.js";
 import { progressLines, WorkflowObservation } from "../workflow-view.js";
@@ -38,7 +38,8 @@ const answer = (value) => toolResult([{ type: "text", text: modelJson(value) }],
  *  agent definition. `workflow` reads and stops runs from the host's side. */
 export function createWorkflowTool(host) {
     // The host's tools pass the check the coding-agent extension's do; the tool's own name and the node runner's submit are reserved.
-    checkHostTools(host.tools ?? [], { reserved: [host.name ?? "agentrun", "submit"], executable: false });
+    const name = host.name ?? "agentrun";
+    assertHostTools(host.tools ?? [], { reserved: [name, SUBMIT_TOOL], executable: false });
     const names = (host.tools ?? []).map((tool) => tool.name);
     const checker = () => new WorkflowExtensionService({ allowedTools: names });
     /** Inspect's checks, after naming any tool the workflow uses (a call's, or an agent node's) that the host did not
@@ -86,7 +87,7 @@ export function createWorkflowTool(host) {
         },
     });
     const tool = defineTool({
-        name: host.name ?? "agentrun",
+        name,
         description: "Compose and run AgentRun workflows in this session. Describe lists the tools a workflow may use, as a call's tool or an agent node's tools, and the language; a workflow uses only the tools describe lists, which the host registers. Inspect validates a complete workflow and keeps it as this conversation's draft. Dry-run checks the draft on synthetic values (or the given input) with no model, Jev or tool call. Run starts the draft as a durable task of this conversation and answers with its outcome. Running the same draft on the same input again, after a restart too, reaches the same run and makes no effect twice; again: true starts a fresh run of them, which a later run then reaches. Save, load and list keep named definition revisions.",
         parameters: Type.Object({ ...workflowToolProperties(), again: Type.Optional(Type.Boolean({ description: "Run only: start a fresh run of the same draft and input instead of reaching the one already run." })) }),
         executionMode: "sequential",

package/dist/extension.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { Compile } from 'typebox/compile';
-import { checkHostTools } from './host-tools.js';
+import { assertHostTools, SUBMIT_TOOL } from './host-tools.js';
 import { Text } from '@earendil-works/pi-tui';
 import { createReadToolDefinition, createBashToolDefinition, createEditToolDefinition, createWriteToolDefinition, createGrepToolDefinition, createFindToolDefinition, createLsToolDefinition, VERSION as PI_VERSION, } from '@earendil-works/pi-coding-agent';
 import { formatWorkflowTree, inspectWorkflow, AUTHOR_SKILL_NAME } from '@parcha/agentrun-dsl';
@@ -29,6 +29,8 @@ const constructors = {
     write: createWriteToolDefinition, grep: createGrepToolDefinition, find: createFindToolDefinition, ls: createLsToolDefinition,
 };
 const mutatingTools = new Set(['bash', 'edit', 'write']);
+/** The extension's own tool's name, which a host tool may not take. */
+const toolName = 'agentrun';
 const help = 'Describe a task: /agentrun <what you want done>\nTry support triage: /agentrun triage (fictional, no model calls)\nInspect: /agentrun · Change input: /agentrun input\nSave: /agentrun save <name> · Load: /agentrun load <name>\nLibrary: /agentrun list · History: /agentrun history\nRun: /agentrun run · Dry run: /agentrun dry-run · SOP text: /agentrun sop <file> · Setup: /agentrun status\nStop: /agentrun stop (closing the inspector does not stop a run)\nOther examples: /agentrun demo | demo empty | demo live';
 const textResult = (text, details = {}) => ({ content: [{ type: 'text', text: safe(text) }], details });
 function singleTextInput(workflow) {
@@ -79,7 +81,7 @@ function registerExtension(pi, configuration) {
     const toolSet = (ctx, trusted = false) => {
         if (configuration.hostTools) {
             const supplied = configuration.hostTools(ctx);
-            checkHostTools(supplied, { reserved: ['agentrun', 'submit'], executable: true });
+            assertHostTools(supplied, { reserved: [toolName, SUBMIT_TOOL], executable: true });
             return supplied.map(tool => ({ ...tool, parameters: structuredClone(tool.parameters), ...(tool.resultSchema ? { resultSchema: structuredClone(tool.resultSchema) } : {}) }));
         }
         const active = new Set(pi.getActiveTools());
@@ -467,10 +469,10 @@ function registerExtension(pi, configuration) {
             await pending;
     };
     pi.registerTool({
-        name: 'agentrun', label: 'AgentRun workflow',
+        name: toolName, label: 'AgentRun workflow',
         description: `Use the ${AUTHOR_SKILL_NAME} skill to compose workflows.` + ' Describe lists available tools and their schemas. Inspect or run an AgentRun DSL workflow in this Pi session. First inspect to show its graph. Dry-run checks the inspected workflow on synthetic values (or the given input) with no model, Jev or tool call; code runs only with the user command /agentrun dry-run --trusted. Agent nodes capture the active Pi model when execution starts. Code needs the user command /agentrun run --trusted for each run. ' + (configuration.hostTools
             ? 'Only the explicit host-configured tools are available, including during trusted runs. Outer permission hooks are not inherited. '
-            : 'Enabled read-only Pi built-ins are available to declared steps. Shell/write/edit need the trusted command for each run; custom extension tools and permission hooks are not inherited. The search and support_demo tools use fictional supplied sources only. ') + 'Save stores a named procedure revision, not its input or permission. Load preflights current host capabilities. Run always restarts; there is no checkpoint resume. Scripted demos stay scripted on rerun.',
+            : 'Enabled read-only Pi built-ins are available to declared steps. Shell/write/edit need the trusted command for each run; custom extension tools and permission hooks are not inherited. The search and support_demo tools use fictional supplied sources only. ') + 'Save stores a named procedure revision, not its input or permission. Load preflights current host capabilities. A run this session left interrupted or failed resumes from its journal when its draft, input, SOP and tools are unchanged; any other run starts new. Scripted demos stay scripted on rerun.',
         parameters: workflowToolParameters(),
         executionMode: 'sequential',
         renderResult(result, options) {

package/dist/host-session.js

@@ -1,4 +1,5 @@
 import { Agent } from '@earendil-works/pi-agent-core';
+import { SUBMIT_TOOL } from './host-tools.js';
 import { createPiRunner } from './runner.js';
 import { workflowToolContext } from './tool-context.js';
 export const PI_MODEL_SETUP_MESSAGE = 'AgentRun requires an active Pi model. Use /login to connect a provider, then /model to select it. Try /agentrun demo without model access.';
@@ -28,7 +29,7 @@ export function createPiHostSessionFactory(context) {
             parameters: tool.parameters,
             async execute(id, args, signal, onUpdate) {
                 const result = await tool.execute(id, args, signal, onUpdate, toolContext);
-                if (tool.name === 'submit' && result.details?.accepted === true)
+                if (tool.name === SUBMIT_TOOL && result.details?.accepted === true)
                     delivered = true;
                 return result;
             },

package/dist/host-tools.d.ts

@@ -1,9 +1,12 @@
+/** The tool a workflow node delivers its result with (the runner's and the durable record tool's), so no host tool may
+ *  take its name. */
+export declare const SUBMIT_TOOL = "submit";
 /**
  * Refuses a host's tool list unless it is an array of at most 100 tools, each with a name of 1 to 200 characters that
  * is not blank, not in `reserved` and not repeated, and an object parameter schema (and result schema, when given) the
  * compiler takes. With `executable`, each tool also needs an `execute` function. Throws on the first problem.
  */
-export declare function checkHostTools(tools: unknown, options: {
+export declare function assertHostTools(tools: unknown, options: {
     reserved: readonly string[];
     executable: boolean;
 }): void;

package/dist/host-tools.js

@@ -3,12 +3,15 @@
 import { Compile } from 'typebox/compile';
 /** The most tools a host may register. */
 const MAX_HOST_TOOLS = 100;
+/** The tool a workflow node delivers its result with (the runner's and the durable record tool's), so no host tool may
+ *  take its name. */
+export const SUBMIT_TOOL = 'submit';
 /**
  * Refuses a host's tool list unless it is an array of at most 100 tools, each with a name of 1 to 200 characters that
  * is not blank, not in `reserved` and not repeated, and an object parameter schema (and result schema, when given) the
  * compiler takes. With `executable`, each tool also needs an `execute` function. Throws on the first problem.
  */
-export function checkHostTools(tools, options) {
+export function assertHostTools(tools, options) {
     if (!Array.isArray(tools) || tools.length > MAX_HOST_TOOLS)
         throw new Error(`Host must supply at most ${MAX_HOST_TOOLS} explicit tool definitions`);
     const names = new Set();

package/dist/runner.js

@@ -1,5 +1,6 @@
 import { Compile } from "typebox/compile";
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, ModelRuntime, } from "@earendil-works/pi-coding-agent";
+import { SUBMIT_TOOL } from "./host-tools.js";
 import { PiRunError } from "./run-error.js";
 import { nodeThinking } from "./thinking.js";
 export { PiRunError } from "./run-error.js";
@@ -49,7 +50,7 @@ export function createPiRunner(options) {
     const timeoutMs = options.timeoutMs === null ? null : positive(options.timeoutMs ?? 120_000, "timeoutMs");
     const names = new Set();
     for (const tool of options.tools ?? []) {
-        if (tool.name === "submit" || names.has(tool.name))
+        if (tool.name === SUBMIT_TOOL || names.has(tool.name))
             throw new Error(`Reserved or duplicate Pi tool: ${tool.name}`);
         names.add(tool.name);
     }
@@ -96,7 +97,7 @@ export function createPiRunner(options) {
         let unsubscribe;
         const result = (text, ok) => ({ content: [{ type: "text", text }], details: { accepted: ok } });
         const submit = {
-            name: "submit", label: "Submit result", description: "Deliver a result matching the required JSON Schema. Rejection feedback must be corrected in this session.",
+            name: SUBMIT_TOOL, label: "Submit result", description: "Deliver a result matching the required JSON Schema. Rejection feedback must be corrected in this session.",
             parameters,
             executionMode: "sequential",
             async execute(id, args) {
@@ -162,7 +163,7 @@ export function createPiRunner(options) {
                 cwd, model: options.model, modelRuntime: options.modelRuntime,
                 thinkingLevel: nodeThinking(request.thinking, options.thinkingLevel), maxTurns: maxTurns ?? undefined, resourceLoader, settingsManager,
                 sessionManager,
-                tools: [...requested, "submit"],
+                tools: [...requested, SUBMIT_TOOL],
                 customTools: [...(options.tools ?? []).filter(tool => requested.includes(tool.name)).map(tool => ({
                         ...tool,
                         executionMode: "sequential",
@@ -192,7 +193,7 @@ export function createPiRunner(options) {
             unsubscribe = session.subscribe(event => {
                 // Native events carry correlation IDs, including SDK-rejected calls. Custom
                 // sessions without IDs use execute's counter so one attempt is not counted twice.
-                if (event.type === "tool_execution_start" && event.toolName === "submit" && event.toolCallId !== undefined && !accepted && !stopped && !fatal) {
+                if (event.type === "tool_execution_start" && event.toolName === SUBMIT_TOOL && event.toolCallId !== undefined && !accepted && !stopped && !fatal) {
                     submissions++;
                     pendingSubmissions.set(event.toolCallId, {
                         ...(Object.hasOwn(event, "args") ? { args: structuredClone(event.args) } : {}), executed: false,
@@ -200,7 +201,7 @@ export function createPiRunner(options) {
                     if (maxSubmissions !== null && submissions > maxSubmissions)
                         stop("submission_limit");
                 }
-                if (event.type === "tool_execution_end" && event.toolName === "submit") {
+                if (event.type === "tool_execution_end" && event.toolName === SUBMIT_TOOL) {
                     if (event.toolCallId !== undefined)
                         pendingSubmissions.delete(event.toolCallId);
                     if (!accepted && !stopped && !fatal && maxSubmissions !== null && submissions >= maxSubmissions)
@@ -228,7 +229,8 @@ export function createPiRunner(options) {
                 throw new PiRunError(stopped, turns, submissions);
             if (accepted)
                 return submission;
-            throw new PiRunError(maxTurns !== null && turns >= maxTurns ? "turn_limit" : "no_submission", turns, submissions);
+            // The loop ends only on one of the three above or at the turn cap, so what is left is the cap.
+            throw new PiRunError("turn_limit", turns, submissions);
         }
         catch (error) {
             if (fatal)

package/dist/workflow-tool.d.ts

@@ -1,6 +1,6 @@
 import { Type } from 'typebox';
 import { type AuthorHostAddendum, type DryRunResult, type WorkflowDeps } from '@parcha/agentrun-dsl';
-import type { WorkflowExtensionService } from './extension-service.js';
+import { type WorkflowExtensionService } from './extension-service.js';
 export declare const WORKFLOW_TOOL_ACTIONS: readonly ["describe", "inspect", "dry-run", "run", "save", "load", "list"];
 /** The tool's fields: one action, and the fields an action reads. A host's tool may add its own. */
 export declare const workflowToolProperties: () => {

package/dist/workflow-tool.js

@@ -2,6 +2,7 @@
 // and the dry run. Nothing here imports pi's coding agent, its agent core or its TUI, so a pi-durable host can use it.
 import { Type } from 'typebox';
 import { compileTransform, dryRunWorkflow, formatWorkflowTree, inspectWorkflow, loadAuthorReference, renderAuthorHostAddendum, } from '@parcha/agentrun-dsl';
+import { ExtensionServiceError } from './extension-service.js';
 import { PI_HOST_ADDENDUM } from './host-addendum.js';
 export const WORKFLOW_TOOL_ACTIONS = ['describe', 'inspect', 'dry-run', 'run', 'save', 'load', 'list'];
 /** The tool's fields: one action, and the fields an action reads. A host's tool may add its own. */
@@ -35,7 +36,9 @@ export function inspectCandidate(checker, candidate, input) {
         inspection = checker.preflight(candidate, input);
     }
     catch (error) {
-        throw new Error(`Cannot inspect workflow: ${error instanceof Error ? error.message : 'Invalid workflow'}`);
+        const message = `Cannot inspect workflow: ${error instanceof Error ? error.message : 'Invalid workflow'}`;
+        // The service's refusal keeps its type and code, so a host branches on it as it does for a run; either keeps its cause.
+        throw error instanceof ExtensionServiceError ? Object.assign(new ExtensionServiceError(error.code, message), { cause: error }) : new Error(message, { cause: error });
     }
     return { inspection, tree: formatWorkflowTree(inspection) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcha/agentrun-pi",
-  "version": "0.1.0-beta.23",
+  "version": "0.1.0-beta.26",
   "description": "Pi extension for building, running and evaluating AgentRun workflows",
   "type": "module",
   "license": "Apache-2.0",
@@ -50,12 +50,12 @@
     "@earendil-works/pi-coding-agent": "1.1.0",
     "@earendil-works/pi-durable": "1.1.0",
     "@earendil-works/pi-tui": "1.1.0",
-    "@parcha/pi-durable-disk": "0.1.0-beta.23",
+    "@parcha/pi-durable-disk": "0.1.0-beta.26",
     "typebox": "1.3.7"
   },
   "dependencies": {
-    "@parcha/agentrun-dsl": "0.1.0-beta.23",
-    "@parcha/agentrun-jev": "0.1.0-beta.23"
+    "@parcha/agentrun-dsl": "0.1.0-beta.26",
+    "@parcha/agentrun-jev": "0.1.0-beta.26"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",