@themoltnet/pi-extension 0.30.0 → 0.31.1

package/README.md

@@ -216,8 +216,9 @@ 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.
+cache: enabling package-manager shims or lightweight repo-local setup. Keep
+network-heavy dependency fetches out of the default TUI startup path; run them
+explicitly when a daemon/provisioning flow wants to prewarm a store.
 
 Important properties:
 
@@ -284,16 +285,22 @@ Dogfood trail:
 - `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:
+The extension now always shadows any `node_modules` path into VM-local
+executable storage. That is VFS policy rather than a resume command, so it also
+covers worktrees the live agent creates after resume. Package-manager stores
+are different: pnpm's content-addressed store should remain a reusable
+guest-local directory, e.g. `NPM_CONFIG_STORE_DIR=/opt/pnpm-store`, not tmpfs.
+Runtime profiles or `sandbox.json` should avoid network-heavy fetch/install
+steps during the default TUI resume path. If a daemon/provisioning flow needs
+fast first installs, prewarm the store explicitly with `pnpm fetch` after the
+sandbox is available.
 
-- package store on guest-local disk, e.g. `NPM_CONFIG_STORE_DIR=/opt/pnpm-store`
-- install target on guest tmpfs via `resumeCommands`
+Run the real VM integration check locally with:
 
-Current themoltnet `sandbox.json` does this by mounting tmpfs over the root and
-per-workspace `node_modules` directories before running `pnpm install
---frozen-lockfile`.
+```bash
+MOLTNET_PI_VM_INTEGRATION=1 \
+  pnpm exec nx run @themoltnet/pi-extension:test-ci--src/vm-manager.integration.test.ts
+```
 
 ### `env`
 

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { BashOperations } from '@earendil-works/pi-coding-agent';
 import { connect } from '@themoltnet/sdk';
 import { EditOperations } from '@earendil-works/pi-coding-agent';
 import { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { LoadSkillsResult } from '@earendil-works/pi-coding-agent';
 import { Model } from '@earendil-works/pi-ai';
 import { Readable } from 'node:stream';
@@ -145,6 +146,16 @@ export declare function createMoltNetTools(config: MoltNetToolsConfig): ToolDefi
 
 export declare function createPiOtelExtension(options?: PiOtelOptions): (pi: ExtensionAPI) => void;
 
+export declare function createPiProviderErrorRetryUi(ctx: ExtensionContext): ProviderErrorRetryUi | undefined;
+
+export declare function createPiRetryTriage(options: {
+    model: Model<Api>;
+    thinkingLevel?: PiRetryTriageThinkingLevel | null;
+    piAgentDir: string;
+    timeoutMs?: number;
+    cwd?: string;
+}): PiRetryTriage;
+
 /**
  * Factory that builds a pi-specific `executeTask` function suitable for
  * injection into `AgentRuntime`. The returned function caches the resolved
@@ -365,6 +376,34 @@ export declare interface ExecutePiTaskOptions {
      * Default `3`. Set to `0` to disable. Closes part of #1094.
      */
     maxBashTimeouts?: number;
+    /**
+     * Number of correction turns allowed after the first invalid submit-output
+     * tool call. A value of 2 permits three invalid submit calls total before
+     * the attempt fails with output_validation_failed.
+     */
+    maxSubmitValidationRetries?: number;
+    /**
+     * Cap provider-error retries inside the same Pi session. A retry is attempted
+     * only after a Pi assistant turn ends with `stopReason: "error"` and the
+     * provider diagnostic is not a known credential/model/config failure. This is
+     * distinct from daemon attempt retry: the active session keeps its context and
+     * receives a short continuation prompt.
+     *
+     * Default `2`. Set to `0` to disable.
+     */
+    maxProviderErrorRetries?: number;
+    /** Base delay for same-session provider-error retries. Default `2000`. */
+    providerErrorRetryBaseDelayMs?: number;
+    /** Maximum delay for same-session provider-error retries. Default `30000`. */
+    providerErrorRetryMaxDelayMs?: number;
+    /** Continuation prompt sent after a retryable provider error. Default `Go on`. */
+    providerErrorRetryPrompt?: string;
+    /**
+     * Optional UI adapter for interactive pi/TUI callers. The daemon normally
+     * leaves this unset and consumes the structured `provider_error_retry` task
+     * message instead.
+     */
+    providerErrorRetryUi?: ProviderErrorRetryUi;
     /**
      * Skip per-call UI approval for matching `moltnet_host_exec` commands.
      * Keep false/undefined for interactive consumers. `true` skips every dialog
@@ -524,6 +563,8 @@ declare interface MoltNetToolsConfig {
     getTaskContext?(): MoltNetTaskContext | null;
 }
 
+export declare function normalizeRetryTriageResult(value: unknown): PiRetryTriageResult;
+
 export declare interface PiOtelOptions {
     /** Agent name for `gen_ai.agent.name` on the root span. */
     agentName?: string;
@@ -535,6 +576,38 @@ export declare interface PiOtelOptions {
     spanAttributes?: Record<string, string | number | boolean>;
 }
 
+export declare type PiRetryTriage = (input: PiRetryTriageInput) => Promise<PiRetryTriageResult>;
+
+export declare type PiRetryTriageConfidence = RetryTriageConfidence;
+
+export declare type PiRetryTriageDecision = RetryTriageDecision;
+
+export declare interface PiRetryTriageInput {
+    task: {
+        id: string;
+        taskType: string;
+        teamId: string;
+        input: unknown;
+    };
+    attemptN: number;
+    maxAttempts?: number | null;
+    remainingAttempts?: number | null;
+    error: unknown;
+    recentMessages?: {
+        timestamp: string;
+        kind: string;
+        payload: unknown;
+    }[];
+}
+
+export declare interface PiRetryTriageResult {
+    decision: RetryTriageDecision;
+    confidence: RetryTriageConfidence;
+    reason: string;
+}
+
+export declare type PiRetryTriageThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+
 export declare interface PiSessionPersistencePlan {
     sessionDir: string;
     forkFromSessionPath?: string | null;
@@ -605,6 +678,28 @@ declare interface PiWorkspaceSeedPlan {
     source: 'producer';
 }
 
+export declare interface ProviderErrorRetryEvent extends Record<string, unknown> {
+    event: 'provider_error_retry';
+    retry: number;
+    maxRetries: number;
+    delayMs: number;
+    reason: string;
+}
+
+export declare type ProviderErrorRetryLevel = 'info' | 'warning' | 'error';
+
+export declare interface ProviderErrorRetryUi {
+    /**
+     * Mirrors pi's `ctx.hasUI`. Undefined means "UI adapter is present"; false
+     * lets callers pass a stable adapter from both TUI and headless contexts.
+     */
+    hasUI?: boolean;
+    setStatus?: (key: string, message: string) => void | Promise<void>;
+    notify?: (message: string, level: ProviderErrorRetryLevel) => void | Promise<void>;
+}
+
+export declare function redactRetryTriageSecrets(value: string): string;
+
 export declare function resolveTaskWorktreePath(mainRepo: string, workspaceId: string): string;
 
 export declare interface ResumeCommand {
@@ -635,6 +730,10 @@ declare interface ResumeCommandWhen {
  */
 export declare function resumeVm(config: VmConfig): Promise<ManagedVm>;
 
+export declare type RetryTriageConfidence = 'low' | 'medium' | 'high';
+
+export declare type RetryTriageDecision = 'retry' | 'do_not_retry';
+
 export declare interface SandboxConfig {
     /** Snapshot build settings. */
     snapshot?: {
@@ -853,6 +952,12 @@ declare const TaskOutput: Type.TObject<{
         message: Type.TString;
         stack: Type.TOptional<Type.TString>;
         retryable: Type.TOptional<Type.TBoolean>;
+        retry: Type.TOptional<Type.TObject<{
+            source: Type.TUnion<[Type.TLiteral<"explicit">, Type.TLiteral<"deterministic">, Type.TLiteral<"attempts_exhausted">, Type.TLiteral<"triage">, Type.TLiteral<"triage_failed">]>;
+            decision: Type.TOptional<Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"do_not_retry">]>>;
+            confidence: Type.TOptional<Type.TUnion<[Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">]>>;
+            reason: Type.TOptional<Type.TString>;
+        }>>;
     }>>;
     contentSignature: Type.TOptional<Type.TString>;
 }>;

package/dist/index.js

@@ -10,7 +10,7 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { pipeline } from "node:stream/promises";
 import { Type, getModel } from "@earendil-works/pi-ai";
-import { MemoryProvider, RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, createShadowPathPredicate, ensureImageSelector, loadGuestAssets } from "@earendil-works/gondolin";
+import { MemoryProvider, RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, createShadowPathPredicate, ensureImageSelector, isWriteFlag, loadGuestAssets } from "@earendil-works/gondolin";
 import { parseEnv } from "node:util";
 import { SpanStatusCode, context, metrics, trace } from "@opentelemetry/api";
 //#region \0rolldown/runtime.js
@@ -1159,7 +1159,7 @@ var listDiaryPacks = (options) => (options.client ?? client).get({
 	...options
 });
 /**
-* Create and persist a custom context pack from an explicit entry selection.
+* Create and persist a custom context pack from an explicit entry selection. Returns 409 if any selected entry is flagged as a prompt-injection risk; the response lists the flagged entries. Set `force: true` to override and persist anyway.
 */
 var createDiaryCustomPack = (options) => (options.client ?? client).post({
 	security: [
@@ -2159,7 +2159,7 @@ var completeTask = (options) => (options.client ?? client).post({
 /**
 * Mark an attempt as failed with error details.
 */
-var failTask = (options) => (options.client ?? client).post({
+var failTaskAttempt = (options) => (options.client ?? client).post({
 	security: [
 		{
 			scheme: "bearer",
@@ -14019,6 +14019,27 @@ var TaskUsage = _Object_({
 	$id: "TaskUsage",
 	additionalProperties: false
 });
+var TaskRetryDecision = Union([Literal("retry"), Literal("do_not_retry")]);
+var TaskRetryConfidence = Union([
+	Literal("low"),
+	Literal("medium"),
+	Literal("high")
+]);
+var TaskRetryInfo = _Object_({
+	source: Union([
+		Literal("explicit"),
+		Literal("deterministic"),
+		Literal("attempts_exhausted"),
+		Literal("triage"),
+		Literal("triage_failed")
+	]),
+	decision: Optional(TaskRetryDecision),
+	confidence: Optional(TaskRetryConfidence),
+	reason: Optional(String$1())
+}, {
+	$id: "TaskRetryInfo",
+	additionalProperties: false
+});
 /**
 * Structured error returned from a failed attempt.
 */
@@ -14026,7 +14047,8 @@ var TaskError = _Object_({
 	code: String$1(),
 	message: String$1(),
 	stack: Optional(String$1()),
-	retryable: Optional(Boolean$1())
+	retryable: Optional(Boolean$1()),
+	retry: Optional(TaskRetryInfo)
 }, {
 	$id: "TaskError",
 	additionalProperties: false
@@ -14157,7 +14179,7 @@ _Object_({
 * @param errors - Field-level errors from `@moltnet/tasks` validators.
 * @returns One line per error, joined by newlines.
 */
-function formatValidationErrors(errors) {
+function formatValidationErrors$1(errors) {
 	return errors.map((e) => `${e.field}: ${e.message}`).join("\n");
 }
 /**
@@ -14170,7 +14192,7 @@ var TaskBuildError = class extends Error {
 	/** The field-level validation errors that caused the build to fail. */
 	errors;
 	constructor(errors) {
-		super(`Task build failed:\n${formatValidationErrors(errors)}`);
+		super(`Task build failed:\n${formatValidationErrors$1(errors)}`);
 		this.name = "TaskBuildError";
 		this.errors = errors;
 	}
@@ -14185,7 +14207,7 @@ var TaskResultError = class extends Error {
 	/** The field-level errors describing why the result could not be read. */
 	errors;
 	constructor(errors) {
-		super(`Task result error:\n${formatValidationErrors(errors)}`);
+		super(`Task result error:\n${formatValidationErrors$1(errors)}`);
 		this.name = "TaskResultError";
 		this.errors = errors;
 	}
@@ -14992,8 +15014,8 @@ function createTasksNamespace(context) {
 				body
 			}));
 		},
-		async fail(id, n, body) {
-			return unwrapResult(await failTask({
+		async failAttempt(id, n, body) {
+			return unwrapResult(await failTaskAttempt({
 				client,
 				auth,
 				path: {
@@ -18722,6 +18744,37 @@ function shouldRunResumeCommand(entry, ctx) {
 	if (workspaceModes && !workspaceModes.includes(ctx.workspaceMode)) return false;
 	return true;
 }
+function shouldShadowNodeModulesPath(pathname) {
+	const normalized = path.posix.normalize(pathname);
+	return normalized === "/node_modules" || normalized.startsWith("/node_modules/") || normalized.endsWith("/node_modules") || normalized.includes("/node_modules/");
+}
+function isNodeModulesBinPath(pathname) {
+	const normalized = path.posix.normalize(pathname);
+	return normalized.includes("/node_modules/.bin/") || normalized.startsWith("/node_modules/.bin/");
+}
+var AutoParentMemoryProvider = class extends MemoryProvider {
+	ensureParentDir(pathname) {
+		const parent = path.posix.dirname(path.posix.normalize(pathname));
+		if (!parent || parent === "/" || parent === ".") return;
+		this.mkdirSync(parent, { recursive: true });
+	}
+	async mkdir(pathname, options) {
+		this.ensureParentDir(pathname);
+		return super.mkdir(pathname, options);
+	}
+	mkdirSync(pathname, options) {
+		this.ensureParentDir(pathname);
+		return super.mkdirSync(pathname, options);
+	}
+	async open(pathname, flags, mode) {
+		if (isWriteFlag(flags)) this.ensureParentDir(pathname);
+		return super.open(pathname, flags, isWriteFlag(flags) && isNodeModulesBinPath(pathname) ? (mode ?? 493) | 73 : mode);
+	}
+	openSync(pathname, flags, mode) {
+		if (isWriteFlag(flags)) this.ensureParentDir(pathname);
+		return super.openSync(pathname, flags, isWriteFlag(flags) && isNodeModulesBinPath(pathname) ? (mode ?? 493) | 73 : mode);
+	}
+};
 /**
 * Resolve the main worktree root (where .moltnet/ lives — it's untracked,
 * only exists in the main worktree, not in git worktrees).
@@ -18872,6 +18925,12 @@ async function resumeVm(config) {
 	vmAgentEnv.MOLTNET_CREDENTIALS_PATH = `${vmAgentDir}/moltnet.json`;
 	const vfsConfig = config.sandboxConfig?.vfs;
 	let workspaceProvider = new RealFSProvider(config.mountPath);
+	workspaceProvider = new ShadowProvider(workspaceProvider, {
+		shouldShadow: ({ path: shadowPath }) => shouldShadowNodeModulesPath(shadowPath),
+		denySymlinkBypass: false,
+		tmpfs: new AutoParentMemoryProvider(),
+		writeMode: "tmpfs"
+	});
 	if (vfsConfig?.shadow?.length) {
 		const predicate = createShadowPathPredicate(vfsConfig.shadow);
 		workspaceProvider = new ShadowProvider(workspaceProvider, {
@@ -19610,17 +19669,17 @@ function createPiModelOptionsExtension(options) {
 	};
 }
 function applyPiModelOptions(payload, options) {
-	if (!isRecord(payload)) return void 0;
+	if (!isRecord$1(payload)) return void 0;
 	if (!hasPiModelOptions(options)) return void 0;
 	if (isGooglePayload(payload)) {
-		const config = isRecord(payload.config) ? payload.config : {};
+		const config = isRecord$1(payload.config) ? payload.config : {};
 		return {
 			...payload,
 			config: applyConfigOptions(config, options)
 		};
 	}
 	if (isBedrockPayload(payload)) {
-		const inferenceConfig = isRecord(payload.inferenceConfig) ? payload.inferenceConfig : {};
+		const inferenceConfig = isRecord$1(payload.inferenceConfig) ? payload.inferenceConfig : {};
 		return {
 			...payload,
 			inferenceConfig: applyBedrockOptions(inferenceConfig, options)
@@ -19673,11 +19732,11 @@ function isAnthropicPayload(payload) {
 	return "anthropic_version" in payload;
 }
 function hasActiveThinking(value) {
-	if (!isRecord(value)) return false;
+	if (!isRecord$1(value)) return false;
 	const type = value.type;
 	return type !== "disabled" && type !== "off" && type !== false;
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -19860,7 +19919,7 @@ function getSubmitOutputContract(taskType) {
 	return {
 		toolName: submitOutputToolName(taskType),
 		taskType,
-		description: `Submit the structured output for this ${taskType} task. Call exactly once when done. The arguments below ARE the output payload — pass each top-level field of the task type's output schema directly. The runtime validates the args against the schema; mismatches return a tool error you can recover from in the same session. On a valid call the runtime captures the payload and ends the session — you do not need to repeat the JSON in your final assistant message.`,
+		description: `Submit the structured output for this ${taskType} task. Call exactly once when done. The arguments below ARE the output payload — pass each top-level field of the task type's output schema directly. The runtime validates the args against the schema; mismatches return a tool error you can recover from in the same session. On a valid call the runtime captures the payload for attempt completion — you do not need to repeat the JSON in your final assistant message.`,
 		parametersSchema: schema
 	};
 }
@@ -19911,7 +19970,7 @@ function buildFinalOutputBlock(opts) {
 		`output matching \`${outputSchemaName}\`.`,
 		"",
 		`Call \`${submitTool}\` exactly once with the payload.`,
-		`The runtime captures the validated arguments and ends the session.`,
+		`The runtime captures the validated arguments for attempt completion.`,
 		`Do NOT emit the output as plain assistant text. Do NOT rely on a`,
 		`JSON-in-message fallback. If you do not call \`${submitTool}\`, the`,
 		`attempt is recorded as failing the promised submit-output criterion`,
@@ -20650,7 +20709,7 @@ function buildJudgeEvalAttemptUserPrompt(input, ctx) {
 					`  "targetTaskId": "${input.targetTaskId}",`,
 					`  "targetAttemptN": ${input.targetAttemptN},`,
 					"  \"variantLabel\": \"<from producer input>\",",
-					"  \"scores\": [ { \"criterionId\": \"...\", \"score\": 0..1, \"rationale\": \"...\", \"assertions\": [...]? } ],",
+					"  \"scores\": [ { \"criterionId\": \"...\", \"score\": 0..1, \"rationale\": \"...\", \"assertions\": [...]?, \"evidence\": { \"text\": \"...\" } } ],",
 					"  \"composite\": <Σ(weight × score), 0..1>,",
 					"  \"verdict\": \"<1-3 sentences>\",",
 					"  \"judgeModel\": \"<id>\",  // optional",
@@ -24897,8 +24956,172 @@ async function resolvePriorContext(agent, continueFrom) {
 	};
 }
 //#endregion
+//#region src/runtime/retry-triage.ts
+var MAX_TRIAGE_JSON_CHARS = 12e3;
+var MAX_TRIAGE_FIELD_CHARS = 2e3;
+var REDACTED = "[redacted]";
+var SECRET_KEY_PATTERN = /(?:api[_-]?key|token|secret|password|passwd|credential|authorization|private[_-]?key|access[_-]?token|refresh[_-]?token)/i;
+function createPiRetryTriage(options) {
+	return async (input) => {
+		const cwd = options.cwd ?? process.cwd();
+		const capture = createRetryTriageTool();
+		const resourceLoader = new DefaultResourceLoader({
+			cwd,
+			agentDir: options.piAgentDir,
+			appendSystemPrompt: [TRIAGE_SYSTEM_PROMPT],
+			skillsOverride: () => ({
+				skills: [],
+				diagnostics: []
+			})
+		});
+		await resourceLoader.reload();
+		const sessionManager = SessionManager.inMemory(cwd);
+		const created = await createAgentSession({
+			agentDir: options.piAgentDir,
+			cwd,
+			model: options.model,
+			thinkingLevel: options.thinkingLevel ?? void 0,
+			customTools: [capture.tool],
+			sessionManager,
+			resourceLoader
+		});
+		await withTimeout(created.session.prompt(buildTriagePrompt(input)), options.timeoutMs ?? 3e4, () => created.session.abort());
+		const result = capture.getCaptured();
+		if (!result) throw new Error("Retry triage did not submit a decision");
+		return normalizeRetryTriageResult(result);
+	};
+}
+function createRetryTriageTool() {
+	let captured = null;
+	return {
+		tool: defineTool({
+			name: "submit_retry_triage",
+			label: "Submit retry triage",
+			description: "Submit the retry decision for a failed MoltNet task attempt.",
+			parameters: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"decision",
+					"confidence",
+					"reason"
+				],
+				properties: {
+					decision: {
+						type: "string",
+						enum: ["retry", "do_not_retry"]
+					},
+					confidence: {
+						type: "string",
+						enum: [
+							"low",
+							"medium",
+							"high"
+						]
+					},
+					reason: {
+						type: "string",
+						minLength: 1
+					}
+				}
+			},
+			execute(_id, params) {
+				captured = normalizeRetryTriageResult(params);
+				return Promise.resolve({
+					content: [{
+						type: "text",
+						text: "Retry triage captured."
+					}],
+					details: captured,
+					terminate: true
+				});
+			}
+		}),
+		getCaptured: () => captured
+	};
+}
+function normalizeRetryTriageResult(value) {
+	const record = value && typeof value === "object" ? value : {};
+	return {
+		decision: record.decision === "retry" ? "retry" : "do_not_retry",
+		confidence: record.confidence === "high" || record.confidence === "medium" ? record.confidence : "low",
+		reason: typeof record.reason === "string" && record.reason.trim() ? record.reason.trim().slice(0, 500) : "retry triage did not provide a reason"
+	};
+}
+function buildTriagePrompt(input) {
+	const payload = {
+		task: {
+			id: input.task.id,
+			type: input.task.taskType,
+			teamId: input.task.teamId,
+			input: prepareTriagePayload(input.task.input)
+		},
+		attempt: {
+			attemptN: input.attemptN,
+			maxAttempts: input.maxAttempts ?? null,
+			remainingAttempts: input.remainingAttempts ?? null
+		},
+		error: prepareTriagePayload(input.error),
+		recentMessages: prepareTriagePayload((input.recentMessages ?? []).slice(-12))
+	};
+	return [
+		"Classify whether this failed task attempt should be retried.",
+		"",
+		"Retry only when a fresh attempt can plausibly recover without changing the task input.",
+		"Do not retry for policy, validation, credentials, cancellation, model/config, or task-contract failures.",
+		"Submit-output validation errors should have been corrected inside the active Pi session; if one reaches retry triage, treat it as exhausted and choose do_not_retry.",
+		"Use confidence=low when evidence is weak; low confidence must choose do_not_retry.",
+		"Call submit_retry_triage exactly once.",
+		"",
+		truncateString(JSON.stringify(payload, null, 2), MAX_TRIAGE_JSON_CHARS)
+	].join("\n");
+}
+function prepareTriagePayload(value) {
+	return redactAndTruncate(value, []);
+}
+function redactAndTruncate(value, path) {
+	const currentKey = path[path.length - 1] ?? "";
+	if (SECRET_KEY_PATTERN.test(currentKey)) return REDACTED;
+	if (typeof value === "string") return truncateString(redactRetryTriageSecrets(value), MAX_TRIAGE_FIELD_CHARS);
+	if (Array.isArray(value)) return value.map((item, index) => redactAndTruncate(item, [...path, String(index)]));
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value).map(([key, child]) => [key, redactAndTruncate(child, [...path, key])]);
+		return Object.fromEntries(entries);
+	}
+	return value;
+}
+function redactRetryTriageSecrets(value) {
+	return value.replace(/((?:bearer|basic)\s+)[a-z0-9._~+/=-]{16,}/gi, `$1${REDACTED}`).replace(/\bgh[pousr]_[a-z0-9_]{20,}\b/gi, REDACTED).replace(/\bsk-[a-z0-9_-]{16,}\b/gi, REDACTED).replace(/\beyJ[a-z0-9_-]{20,}\.[a-z0-9_-]{20,}\.[a-z0-9_-]{20,}\b/gi, REDACTED);
+}
+function truncateString(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}...[truncated ${value.length - maxChars} chars]`;
+}
+var TRIAGE_SYSTEM_PROMPT = [
+	"You are MoltNet retry triage.",
+	"You classify one failed execution attempt, not the whole task.",
+	"Return retry only for likely transient/runtime failures or clear evidence a new attempt can recover.",
+	"The agent may have already tried local recovery; do not ask for more work."
+].join("\n");
+async function withTimeout(promise, timeoutMs, onTimeout) {
+	let timeout;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeout = setTimeout(() => {
+			Promise.resolve(onTimeout?.()).catch(() => {});
+			reject(/* @__PURE__ */ new Error(`Retry triage timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([promise, timeoutPromise]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+//#endregion
 //#region src/runtime/subagent-tool.ts
 var SUBAGENT_SUBMIT_TOOL_NAME = "submit_subagent_output";
+var DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES = 2;
+var RecoverableSubagentSubmitParameters = _Object_({}, { additionalProperties: Unknown() });
 /**
 * Parameters shape the parent LLM sees when calling the subagent tool.
 *
@@ -24942,21 +25165,44 @@ function createSubagentTool(args) {
 				callCount += 1;
 				const callIndex = callCount;
 				let captured = null;
+				let innerInvalidSubmitCount = 0;
+				let innerValidationFailure = null;
+				let innerValidationExhausted = false;
 				const submitTool = defineTool({
 					name: SUBAGENT_SUBMIT_TOOL_NAME,
 					label: `Submit ${output_schema}`,
 					description: `Submit your structured output for this subagent task. Call exactly once when done. Args MUST match the ${output_schema} contract; mismatches return a tool error you can recover from in the same session.`,
-					parameters: contract.parametersSchema,
+					promptSnippet: `${SUBAGENT_SUBMIT_TOOL_NAME}: submit the final structured ${output_schema} payload.`,
+					promptGuidelines: [`Call \`${SUBAGENT_SUBMIT_TOOL_NAME}\` with the exact \`${output_schema}\` contract shape.`, "If the submit tool returns a validation error, fix every listed field and call the same tool again."],
+					parameters: RecoverableSubagentSubmitParameters,
 					async execute(_innerId, innerParams) {
-						if (!Check(contract.parametersSchema, innerParams)) return toolError(`submit_subagent_output: schema validation failed: ${[...Errors(contract.parametersSchema, innerParams)].slice(0, 3).map((e) => `${e.instancePath}: ${e.message}`).join("; ")}. Re-call with a corrected payload.`);
+						if (innerValidationExhausted) return toolError("submit_subagent_output validation retry budget is already exhausted.", {
+							captured: false,
+							error: "output_validation_failed",
+							invalidCallCount: innerInvalidSubmitCount,
+							maxSubmitValidationRetries: DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES
+						});
+						if (!Check(contract.parametersSchema, innerParams)) {
+							innerInvalidSubmitCount += 1;
+							const maxInvalidCalls = DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES + 1;
+							const exhausted = innerInvalidSubmitCount >= maxInvalidCalls;
+							const errs = [...Errors(contract.parametersSchema, innerParams)].map((e) => `${e.instancePath}: ${e.message}`).join("; ");
+							innerValidationFailure = `submit_subagent_output validation failed (${innerInvalidSubmitCount}/${maxInvalidCalls}): ${errs}. ` + (exhausted ? "Validation retry budget exhausted." : "Re-call with a corrected payload.");
+							if (exhausted) innerValidationExhausted = true;
+							return toolError(innerValidationFailure, {
+								captured: false,
+								error: "output_validation_failed",
+								invalidCallCount: innerInvalidSubmitCount,
+								maxSubmitValidationRetries: DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES
+							});
+						}
 						captured = innerParams;
 						return {
 							content: [{
 								type: "text",
-								text: "Output captured. Subagent session will terminate; no further action needed."
+								text: "Output captured. No further action needed for subagent output reporting."
 							}],
-							details: { captured: true },
-							terminate: true
+							details: { captured: true }
 						};
 					}
 				});
@@ -25020,7 +25266,16 @@ function createSubagentTool(args) {
 					if (cancelListener) cancelListener();
 				}
 				if (abortReason !== null) return toolError(`subagent: ${abortReason === "subagent_timed_out" ? `subagent timed out after ${timeoutMs}ms` : "parent task was cancelled"}. The parent should fail this task or retry with a clearer scope.`);
-				if (captured === null) return toolError(`subagent: inner session ended without calling ${SUBAGENT_SUBMIT_TOOL_NAME}. The parent should retry with clearer instructions or fail the task.`);
+				if (captured === null) {
+					const exhaustedFailure = innerValidationFailure;
+					if (innerValidationExhausted && exhaustedFailure) return toolError(`subagent: ${exhaustedFailure}`, {
+						captured: false,
+						error: "output_validation_failed",
+						invalidCallCount: innerInvalidSubmitCount,
+						maxSubmitValidationRetries: DEFAULT_SUBAGENT_SUBMIT_VALIDATION_RETRIES
+					});
+					return toolError(`subagent: inner session ended without calling ${SUBAGENT_SUBMIT_TOOL_NAME}. The parent should retry with clearer instructions or fail the task.`);
+				}
 				return {
 					content: [{
 						type: "text",
@@ -25065,8 +25320,7 @@ function buildSubagentInstructor(args) {
 		"Rules for this session:",
 		"",
 		`- You MUST call \`${SUBAGENT_SUBMIT_TOOL_NAME}\` exactly once with a `,
-		"  payload matching the contract above. Your session terminates on ",
-		"  the valid call.",
+		"  payload matching the contract above as your final task action.",
 		"- The parent's message above is your task. Do not invent additional ",
 		"  steps the parent did not request.",
 		"- All MoltNet runtime invariants from the parent runtime instructor ",
@@ -25077,13 +25331,13 @@ function buildSubagentInstructor(args) {
 		"  delegation; do the work yourself."
 	].join("\n");
 }
-function toolError(text) {
+function toolError(text, details = { captured: false }) {
 	return {
 		content: [{
 			type: "text",
 			text
 		}],
-		details: { captured: false },
+		details,
 		isError: true
 	};
 }
@@ -25230,25 +25484,112 @@ var UnknownTaskTypeForSubmitToolError = class extends Error {
 		this.name = "UnknownTaskTypeForSubmitToolError";
 	}
 };
+var DEFAULT_MAX_SUBMIT_VALIDATION_RETRIES = 2;
+var RecoverableSubmitToolParameters = _Object_({}, { additionalProperties: Unknown() });
+function formatValidationErrors(errors) {
+	return errors.map((err) => `${err.field}: ${err.message}`).join("; ");
+}
+function submitOutputRepairHint(taskType, errors) {
+	const fields = new Set(errors.map((err) => err.field));
+	const hints = ["Tool args must be the output object directly, not wrapped in { output: ... }."];
+	if (fields.has("output/artifacts")) hints.push("`artifacts` must be an array; omit it when there are no artifacts, use [], or use objects like { \"kind\": \"note\", \"title\": \"Result\", \"body\": \"...\" }.");
+	if (fields.has("output/verification")) hints.push("`verification` must be an object with inputCid, results[], and passed; do not send it as text or an array.");
+	if (taskType === "freeform" && (fields.has("output/artifacts") || fields.has("output/verification"))) hints.push("Minimal valid freeform retry: { \"summary\": \"completed\", \"artifacts\": [], \"verification\": { \"inputCid\": \"<task inputCid>\", \"results\": [{ \"id\": \"submit-output\", \"kind\": \"gate\", \"status\": \"pass\", \"detail\": \"submit_freeform_output accepted valid args\" }], \"passed\": true } }.");
+	if (hints.length === 1) hints.push("Fix every listed field before re-calling this same tool.");
+	return hints.join(" ");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlySubmitOutputGate(input) {
+	if (!isRecord(input) || !isRecord(input.successCriteria)) return false;
+	const criteria = input.successCriteria;
+	const gates = criteria.gates;
+	if (!Array.isArray(gates) || gates.length !== 1) return false;
+	const [gate] = gates;
+	if (!isRecord(gate) || gate.id !== "submit-output") return false;
+	const assertions = criteria.assertions;
+	if (Array.isArray(assertions) && assertions.length > 0) return false;
+	return criteria.rubric === void 0 && criteria.sideEffects === void 0 && criteria.minComposite === void 0;
+}
+function repairFreeformSubmitOutput(params, opts) {
+	if (!isRecord(params) || !opts.inputCid || !onlySubmitOutputGate(opts.input)) return null;
+	const repaired = { ...params };
+	if ("artifacts" in repaired && !Array.isArray(repaired.artifacts)) if (isRecord(repaired.artifacts)) repaired.artifacts = [repaired.artifacts];
+	else delete repaired.artifacts;
+	if ("proposedTaskType" in repaired && !isRecord(repaired.proposedTaskType)) if (typeof repaired.proposedTaskType === "string" && repaired.proposedTaskType.length > 0) repaired.proposedTaskType = {
+		name: repaired.proposedTaskType,
+		rationale: "Suggested by the model during freeform execution."
+	};
+	else delete repaired.proposedTaskType;
+	repaired.verification = {
+		inputCid: opts.inputCid,
+		results: [{
+			id: SUBMIT_OUTPUT_GATE_ID,
+			kind: "gate",
+			status: "pass",
+			detail: "submit_freeform_output accepted valid args"
+		}],
+		passed: true
+	};
+	return repaired;
+}
+function maybeRepairSubmitOutput(taskType, params, opts) {
+	if (taskType !== "freeform") return null;
+	const repaired = repairFreeformSubmitOutput(params, opts);
+	if (!repaired) return null;
+	return validateTaskOutput(taskType, repaired, opts.input).length === 0 ? repaired : null;
+}
 function createSubmitOutputTool(taskType, opts = {}) {
 	const contract = getSubmitOutputContract(taskType);
 	if (!contract) throw new UnknownTaskTypeForSubmitToolError(taskType);
-	const schema = contract.parametersSchema;
+	const maxSubmitValidationRetries = opts.maxSubmitValidationRetries ?? DEFAULT_MAX_SUBMIT_VALIDATION_RETRIES;
 	let captured = null;
 	let callCount = 0;
+	let invalidCallCount = 0;
+	let lastValidationFailure = null;
+	let exhaustedValidationFailure = null;
 	return {
 		tool: defineTool({
 			name: contract.toolName,
 			label: `Submit ${taskType} output`,
 			description: contract.description,
-			parameters: schema,
+			promptSnippet: `${contract.toolName}: submit the final structured ${taskType} output using the schema shown in the task prompt.`,
+			promptGuidelines: [`Call \`${contract.toolName}\` with the exact ${taskType} output shape shown in the task prompt.`, "If the submit tool returns a validation error, fix every listed field and call the same tool again."],
+			parameters: RecoverableSubmitToolParameters,
 			async execute(_id, params) {
-				const errors = validateTaskOutput(taskType, params, opts.input);
+				if (exhaustedValidationFailure) return {
+					content: [{
+						type: "text",
+						text: "Submit-output validation retry budget is already exhausted; the attempt will fail."
+					}],
+					details: {
+						captured: false,
+						callCount,
+						invalidCallCount,
+						maxSubmitValidationRetries,
+						error: "output_validation_failed"
+					},
+					isError: true
+				};
+				const candidateParams = maybeRepairSubmitOutput(taskType, params, opts) ?? params;
+				const errors = validateTaskOutput(taskType, candidateParams, opts.input);
 				if (errors.length > 0) {
-					const detailMsg = errors.slice(0, 3).map((err) => `${err.field}: ${err.message}`).join("; ");
+					invalidCallCount += 1;
+					const detailMsg = formatValidationErrors(errors);
+					const maxInvalidCalls = maxSubmitValidationRetries + 1;
+					const exhausted = invalidCallCount >= maxInvalidCalls;
+					const message = `Output failed validation (${invalidCallCount}/${maxInvalidCalls}): ${detailMsg}. ${submitOutputRepairHint(taskType, errors)} ` + (exhausted ? "Submit-output validation retry budget exhausted; the attempt will fail." : "Re-call this tool with a corrected output.");
+					lastValidationFailure = {
+						code: "output_validation_failed",
+						message
+					};
+					if (exhausted) exhaustedValidationFailure = lastValidationFailure;
 					const details = {
 						captured: false,
 						callCount,
+						invalidCallCount,
+						maxSubmitValidationRetries,
 						error: "output_validation_failed"
 					};
 					recordTaskOutputParseResult({
@@ -25259,13 +25600,13 @@ function createSubmitOutputTool(taskType, opts = {}) {
 					return {
 						content: [{
 							type: "text",
-							text: `Output failed validation: ${detailMsg}. Re-call this tool with a corrected output.`
+							text: message
 						}],
 						details,
 						isError: true
 					};
 				}
-				captured = params;
+				captured = candidateParams;
 				callCount += 1;
 				return {
 					content: [{
@@ -25276,13 +25617,15 @@ function createSubmitOutputTool(taskType, opts = {}) {
 						captured: true,
 						callCount,
 						error: null
-					},
-					terminate: true
+					}
 				};
 			}
 		}),
 		getCaptured: () => captured,
-		getCallCount: () => callCount
+		getCallCount: () => callCount,
+		getInvalidCallCount: () => invalidCallCount,
+		getLastValidationFailure: () => lastValidationFailure,
+		getExhaustedValidationFailure: () => exhaustedValidationFailure
 	};
 }
 /**
@@ -25851,7 +26194,9 @@ async function executePiTask(claimedTask, reporter, opts) {
 		});
 		const { handle: submitToolHandle, tools: submitToolDefs } = resolveSubmitTools(task.taskType, {
 			model: opts.model,
-			input: task.input
+			input: task.input,
+			inputCid: task.inputCid,
+			maxSubmitValidationRetries: opts.maxSubmitValidationRetries
 		});
 		const submitTools = submitToolDefs;
 		try {
@@ -26038,19 +26383,28 @@ async function executePiTask(claimedTask, reporter, opts) {
 			}
 		});
 		let runError = null;
-		try {
-			await session.prompt(taskPrompt);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			runError = {
-				code: "session_prompt_failed",
-				message
-			};
-			await emit("error", {
+		runError = (await promptWithProviderErrorRetries({
+			session,
+			initialPrompt: taskPrompt,
+			cancelSignal: reporter.cancelSignal,
+			isCapAborted: () => capAbort !== null,
+			getProviderErrorState: () => ({
+				llmAbort,
+				llmErrorMessage
+			}),
+			maxRetries: opts.maxProviderErrorRetries ?? 2,
+			baseDelayMs: opts.providerErrorRetryBaseDelayMs ?? 2e3,
+			maxDelayMs: opts.providerErrorRetryMaxDelayMs ?? 3e4,
+			retryPrompt: opts.providerErrorRetryPrompt ?? "Go on",
+			onRetry: async (event) => {
+				await emit("info", event);
+				await notifyProviderErrorRetryUi(opts.providerErrorRetryUi, event);
+			},
+			onPromptError: (message) => emit("error", {
 				message,
 				phase: "session_prompt"
-			});
-		}
+			})
+		})).runError;
 		if (subagentHandle && subagentHandle.getCallCount() > 0) await emit("info", {
 			event: "subagent_summary",
 			callCount: subagentHandle.getCallCount()
@@ -26089,7 +26443,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 				});
 			}
 			else if (submitToolHandle) {
-				parseError = {
+				parseError = submitToolHandle.getExhaustedValidationFailure() ?? {
 					code: "submit_output_missing",
 					message: "Agent did not satisfy the promised submit-output criterion: no valid task submit tool call was captured before the session ended."
 				};
@@ -26281,6 +26635,110 @@ function shouldEmitToolCallError(event) {
 	if (event.toolName === "bash") return false;
 	return true;
 }
+var PROVIDER_ERROR_NON_RETRYABLE_PATTERNS = [
+	/\b401\b/i,
+	/\b403\b/i,
+	/\bunauthori[sz]ed\b/i,
+	/\bforbidden\b/i,
+	/\binvalid (?:api )?key\b/i,
+	/\bmissing credentials?\b/i,
+	/\binsufficient[_\s-]?quota\b/i,
+	/\bbilling\b/i,
+	/\bmodel .*not (?:found|registered|available)\b/i,
+	/\bunknown model\b/i
+];
+var PROVIDER_ERROR_RETRYABLE_PATTERNS = [
+	/\b429\b/i,
+	/\b5(?:02|03|04)\b/i,
+	/\btimeout\b/i,
+	/\btimed out\b/i,
+	/\brate limit/i,
+	/\btemporar(?:y|ily)\b/i,
+	/\bunavailable\b/i,
+	/\boverloaded\b/i,
+	/\bECONNRESET\b/i,
+	/\bECONNREFUSED\b/i,
+	/\bETIMEDOUT\b/i,
+	/\bENOTFOUND\b/i,
+	/\bEAI_AGAIN\b/i,
+	/\bDNS\b/i
+];
+function shouldRetryProviderErrorMessage(message) {
+	if (!message || !message.trim()) return true;
+	if (PROVIDER_ERROR_NON_RETRYABLE_PATTERNS.some((pattern) => pattern.test(message))) return false;
+	if (PROVIDER_ERROR_RETRYABLE_PATTERNS.some((pattern) => pattern.test(message))) return true;
+	return true;
+}
+function computeProviderErrorRetryDelay(attempt, baseDelayMs, maxDelayMs) {
+	return Math.min(Math.max(0, baseDelayMs) * 2 ** (attempt - 1), Math.max(0, maxDelayMs));
+}
+function formatProviderErrorRetryStatus(event) {
+	const seconds = Math.ceil(event.delayMs / 1e3);
+	return `Provider retry ${event.retry}/${event.maxRetries} in ${seconds}s`;
+}
+function formatProviderErrorRetryNotification(event) {
+	return `Provider error; retrying same Pi session (${event.retry}/${event.maxRetries}).`;
+}
+async function notifyProviderErrorRetryUi(ui, event) {
+	if (!ui || ui.hasUI === false) return;
+	await ui.setStatus?.("provider_retry", formatProviderErrorRetryStatus(event));
+	await ui.notify?.(formatProviderErrorRetryNotification(event), "warning");
+}
+async function promptWithProviderErrorRetries(args) {
+	let retryCount = 0;
+	let promptText = args.initialPrompt;
+	while (true) {
+		try {
+			await args.session.prompt(promptText);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			await args.onPromptError?.(message);
+			return {
+				runError: {
+					code: "session_prompt_failed",
+					message
+				},
+				retryCount
+			};
+		}
+		const { llmAbort, llmErrorMessage } = args.getProviderErrorState();
+		if (!llmAbort || args.cancelSignal.aborted || args.isCapAborted?.() || retryCount >= args.maxRetries || !shouldRetryProviderErrorMessage(llmErrorMessage)) return {
+			runError: null,
+			retryCount
+		};
+		retryCount += 1;
+		const delayMs = computeProviderErrorRetryDelay(retryCount, args.baseDelayMs, args.maxDelayMs);
+		await args.onRetry?.({
+			event: "provider_error_retry",
+			retry: retryCount,
+			maxRetries: args.maxRetries,
+			delayMs,
+			reason: sanitizeProviderErrorRetryReason(llmErrorMessage)
+		});
+		await sleepUnlessAborted(delayMs, args.cancelSignal);
+		if (args.cancelSignal.aborted || args.isCapAborted?.()) return {
+			runError: null,
+			retryCount
+		};
+		promptText = args.retryPrompt;
+	}
+}
+function sanitizeProviderErrorRetryReason(value) {
+	return redactRetryTriageSecrets(value ?? "Pi turn ended with stopReason=error").slice(0, 500);
+}
+async function sleepUnlessAborted(delayMs, signal) {
+	if (delayMs <= 0 || signal.aborted) return;
+	await new Promise((resolve) => {
+		const timeout = setTimeout(done, delayMs);
+		const onAbort = () => done();
+		function done() {
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 /**
 * Detect pi's bash-timeout error wrapper in a `tool_execution_end`
 * result. The bash tool surfaces a timeout as a structured tool result
@@ -26352,6 +26810,19 @@ function describeToolErrorMessage(result) {
 * See README.md for credential injection flow, tool split, sandbox.json
 * reference, and headless/programmatic usage.
 */
+function createPiProviderErrorRetryUi(ctx) {
+	const hasUI = Boolean(ctx.hasUI);
+	if (!hasUI) return void 0;
+	return {
+		hasUI,
+		setStatus: (key, message) => {
+			ctx.ui.setStatus(key, ctx.ui.theme.fg("muted", message));
+		},
+		notify: (message, level) => {
+			ctx.ui.notify?.(message, level);
+		}
+	};
+}
 function moltnetExtension(pi) {
 	pi.registerFlag("agent", {
 		description: "MoltNet agent name (required — pass --agent <name>)",
@@ -26642,4 +27113,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, resolveTaskWorktreePath, resumeVm, toGuestPath };
+export { HOST_EXEC_DEFAULT_BASE_ENV, activateAgentEnv, buildAgentSession, createGondolinBashOps, createGondolinEditOps, createGondolinReadOps, createGondolinWriteOps, createMoltNetTools, createPiOtelExtension, createPiProviderErrorRetryUi, createPiRetryTriage, createPiTaskExecutor, createSubagentTool, moltnetExtension as default, ensureSnapshot, executePiTask, findMainWorktree, injectTaskContext, loadCredentials, normalizeRetryTriageResult, redactRetryTriageSecrets, resolveTaskWorktreePath, resumeVm, toGuestPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "keywords": [
@@ -36,8 +36,8 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "typebox": "^1.2.8",
-    "@themoltnet/agent-runtime": "0.33.0",
-    "@themoltnet/sdk": "0.116.0"
+    "@themoltnet/agent-runtime": "0.33.2",
+    "@themoltnet/sdk": "0.117.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",