@themoltnet/pi-extension 0.32.0 → 0.33.0

package/dist/index.js

@@ -1965,7 +1965,7 @@ var findLatestRuntimeSlotForAttempt = (options) => (options.client ?? client).ge
 	...options
 });
 /**
-* Delete terminal tasks in bulk. Safe mode skips live, unauthorized, missing, and protected tasks.
+* Queue asynchronous deletion of terminal tasks in bulk. By default, live, unauthorized, missing, and protected tasks are skipped. Set force: true with a reason to delete protected terminal tasks.
 */
 var batchDeleteTasks = (options) => (options.client ?? client).delete({
 	security: [
@@ -18037,7 +18037,7 @@ function createMoltNetTools(config) {
 	const searchEntries = defineTool({
 		name: "moltnet_search_entries",
 		label: "Search MoltNet Diary Entries",
-		description: "Hybrid (semantic + lexical) search over diary entries. Optional tags / excludeTags / entryTypes filters AND with the query; the taskFilter shorthand expands into task:* provenance tags so `taskFilter: { taskType: \"fulfill_brief\" }` returns only entries from fulfill_brief attempts. Filters apply server-side before ranking.",
+		description: "Hybrid (semantic + lexical) search over diary entries. Use proactively before non-trivial investigation, code changes, review, or episodic incident capture so prior decisions and recurring failures surface before you act. Do not search randomly: pass taskFilter for task/correlation-local searches and tags or entryTypes for broader prior-knowledge searches. Optional tags / excludeTags / entryTypes filters AND with the query; the taskFilter shorthand expands into task:* provenance tags so `taskFilter: { taskType: \"fulfill_brief\" }` returns only entries from fulfill_brief attempts. Filters apply server-side before ranking.",
 		parameters: Type.Object({
 			query: Type.String({ description: "Natural language search query" }),
 			limit: Type.Optional(Type.Number({ description: "Max results (default 5)" })),
@@ -18096,12 +18096,18 @@ function createMoltNetTools(config) {
 	const createEntry = defineTool({
 		name: "moltnet_create_entry",
 		label: "Create MoltNet Diary Entry",
-		description: "Create a new diary entry to record decisions, findings, incidents, or reflections. During an active task, the entry is forced into the task diary and tagged with the task:* provenance namespace (task:id:<id>, task:type:<type>, task:attempt:<n>, plus task:correlation:<id> when set); an explicit diaryId mismatching the task diary is rejected. Use this tool — NOT `moltnet entry create` / `moltnet entry create-signed` via bash. The CLI path bypasses task-tag auto-injection and leaves entries invisible to taskFilter queries.",
+		description: "Create a new diary entry to record decisions, findings, incidents, or reflections. Before creating an episodic incident entry, first call moltnet_search_entries with the title/root-cause/error/watch-for terms plus taskFilter, tags, or entryTypes filters, then reference close matches instead of creating an isolated duplicate. During an active task, the entry is forced into the task diary and tagged with the task:* provenance namespace (task:id:<id>, task:type:<type>, task:attempt:<n>, plus task:correlation:<id> when set); an explicit diaryId mismatching the task diary is rejected. Use this tool — NOT `moltnet entry create` / `moltnet entry create-signed` via bash. The CLI path bypasses task-tag auto-injection and leaves entries invisible to taskFilter queries.",
 		parameters: Type.Object({
 			title: Type.String({ description: "Entry title (concise, descriptive)" }),
 			content: Type.String({ description: "Entry content (markdown)" }),
 			tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for categorization" })),
 			importance: Type.Optional(Type.Number({ description: "Importance 1-10 (default 5)" })),
+			entryType: Type.Optional(Type.Union([
+				Type.Literal("episodic"),
+				Type.Literal("semantic"),
+				Type.Literal("procedural"),
+				Type.Literal("reflection")
+			], { description: "Entry type. Use episodic for incidents, workarounds, bugs, or recurrence evidence; defaults to semantic." })),
 			diaryId: Type.Optional(Type.String({ description: "Explicit diary id. During an active task, must match the task diary or the call is rejected. Outside a task, overrides the env-derived diary." }))
 		}),
 		async execute(_id, params) {
@@ -18125,7 +18131,8 @@ function createMoltNetTools(config) {
 				title: params.title,
 				content: params.content,
 				tags: mergedTags,
-				importance: params.importance ?? 5
+				importance: params.importance ?? 5,
+				...params.entryType ? { entryType: params.entryType } : {}
 			});
 			return {
 				content: [{
@@ -18135,6 +18142,8 @@ function createMoltNetTools(config) {
 						title: entry.title,
 						createdAt: entry.createdAt,
 						diaryId: targetDiaryId,
+						entryType: entry.entryType,
+						importance: entry.importance,
 						tags: mergedTags
 					}, null, 2)
 				}],
@@ -18514,6 +18523,29 @@ function buildRuntimeInstructor(ctx) {
 		"  requires human approval and is unavailable in headless task runs;",
 		"  never use it for routine git/gh.",
 		"",
+		"## Proactive memory use",
+		"",
+		"- Before non-trivial investigation, debugging, code changes, or review,",
+		"  check the task diary for relevant prior knowledge instead of waiting",
+		"  for a human to ask. Use `moltnet_diary_tags` for cheap reconnaissance,",
+		"  `moltnet_list_entries` when tags or task provenance are known, and",
+		"  `moltnet_search_entries` for semantic similarity. Do not search",
+		"  randomly: pass `taskFilter` for task-local or correlation-local",
+		"  queries, and pass `tags` / `entryTypes` for broader prior-knowledge",
+		"  queries using known tags such as `incident`, `decision`, or",
+		"  `scope:<area>`. Broaden only after constrained searches miss.",
+		"- Before creating an `episodic` incident entry, you MUST search for",
+		"  similar incidents using the proposed title, root cause, error text,",
+		"  affected subsystem, and watch-for terms, filtered by `entryTypes:",
+		"  [\"episodic\", \"semantic\"]` and any known `scope:*` / task provenance",
+		"  tags. If a close prior match exists, do not create an isolated",
+		"  duplicate: reference the prior entry in your response or diary content,",
+		"  update/link it when the new occurrence adds material evidence, or",
+		"  create a new recurrence entry only when the recurrence itself is",
+		"  important signal.",
+		"- When you create a recurrence entry, include the prior matching entry",
+		"  id(s) in the content and explain what is new about this occurrence.",
+		"",
 		"## Diary discipline",
 		"",
 		`- During this task, every diary entry MUST land in \`${ctx.diaryId}\``,
@@ -20114,6 +20146,22 @@ function buildFinalOutputBlock(opts) {
 	return lines.join("\n");
 }
 //#endregion
+//#region ../agent-runtime/src/prompts/proactive-memory.ts
+function buildProactiveMemoryWorkflowBlock() {
+	return [
+		"Before material work, apply the runtime instructor's proactive memory",
+		"rules instead of waiting for a human prompt. Start with constrained",
+		"diary context: inspect tags/list entries when task provenance or scope",
+		"tags are known, then use `moltnet_search_entries` with `taskFilter`,",
+		"`entryTypes`, and tags. Do not run broad unfiltered searches before",
+		"constrained searches miss.",
+		"",
+		"For incident capture, follow the runtime instructor exactly: search",
+		"for similar episodic/semantic entries first, reference close matches,",
+		"and create a recurrence entry only when the repeat is useful signal."
+	].join("\n");
+}
+//#endregion
 //#region ../agent-runtime/src/prompts/rubric-common.ts
 function renderRubricCriteriaList(rubric) {
 	return rubric.criteria.map((c, i) => `${i + 1}. **${c.id}** (weight ${c.weight}, scoring: \`${c.scoring}\`) — ${c.description}`).join("\n");
@@ -20215,6 +20263,12 @@ function buildAssessBriefUserPrompt(input, ctx) {
 			header: "Querying the producer's diary entries",
 			body: diaryQuery
 		},
+		{
+			id: "assess_brief.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "assess_brief.workspace",
 			source: "workspace",
@@ -20542,11 +20596,13 @@ function buildFreeformUserPrompt(input, ctx) {
 	const suggestedTaskType = input.suggestedTaskType ? [`The proposer suggested task type \`${input.suggestedTaskType}\`.`, "Use it as a hint, not as a contract."].join("\n") : "";
 	const workflow = [
 		"1. Clarify the real objective from the brief before acting.",
-		"2. Gather enough context to avoid guessing.",
-		"3. Complete the requested work when it is safe and bounded.",
-		"4. If the request reveals a recurring task shape, include a",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring traps relevant to the brief.",
+		"3. Gather enough context to avoid guessing.",
+		"4. Complete the requested work when it is safe and bounded.",
+		"5. If the request reveals a recurring task shape, include a",
 		"   `proposedTaskType` in the final output with a concise rationale.",
-		"5. If you changed code on a branch, include that branch in",
+		"6. If you changed code on a branch, include that branch in",
 		"   `branch` so future continuations can recover git context."
 	].join("\n");
 	const sections = [
@@ -20585,6 +20641,12 @@ function buildFreeformUserPrompt(input, ctx) {
 			header: "Workflow",
 			body: workflow
 		},
+		{
+			id: "freeform.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "freeform.verification",
 			source: "verification",
@@ -20661,13 +20723,15 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 	].join("\n") : "";
 	const workflow = [
 		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.",
-		"5. For every commit, create a signed diary entry first via",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring traps relevant to the brief before changing code.",
+		"3. Understand the problem — read relevant code; do not speculate.",
+		"4. Implement the change. Keep commits small and coherent.",
+		"5. Add tests if applicable.",
+		"6. For every commit, create a signed diary entry first via",
 		"   `moltnet_create_entry` and embed its id in the commit trailer",
 		"   `MoltNet-Diary: <id>` (per the runtime instructor).",
-		"6. Push the branch and open a PR — run `git push` and `gh pr create`",
+		"7. Push the branch and open a PR — run `git push` and `gh pr create`",
 		"   IN the VM with your normal `bash` tool (use the",
 		"   `GH_TOKEN=$(moltnet github token …) gh …` form from the runtime",
 		"   instructor). Do NOT use `moltnet_host_exec` for this; it needs human",
@@ -20709,6 +20773,12 @@ function buildFulfillBriefUserPrompt(input, ctx) {
 			header: "Workflow",
 			body: workflow
 		},
+		{
+			id: "fulfill_brief.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "fulfill_brief.verification",
 			source: "verification",
@@ -21024,13 +21094,15 @@ function buildPrReviewUserPrompt(input, ctx) {
 	const workflow = [
 		"1. Read the subject summary, resources, inspection hints, and any",
 		"   task-specific instructions before scoring.",
-		"2. Inspect the target artefact directly using the tools and resources the",
+		"2. Search MoltNet diary memory for prior decisions, incidents, and",
+		"   recurring review traps relevant to the subject.",
+		"3. Inspect the target artefact directly using the tools and resources the",
 		"   task makes available.",
-		"3. If you are in a dedicated disposable worktree and need the review target",
+		"4. If you are in a dedicated disposable worktree and need the review target",
 		"   checked out locally, do that work inside this disposable workspace only.",
-		"4. Apply the rubric strictly. This task is about complexity and",
+		"5. Apply the rubric strictly. This task is about complexity and",
 		"   reviewability, not correctness or feature desirability.",
-		"5. Perform any required outward action before emitting the final",
+		"6. Perform any required outward action before emitting the final",
 		"   structured output."
 	].join("\n");
 	const taskPromptSection = input.taskPrompt ?? "";
@@ -21087,6 +21159,12 @@ function buildPrReviewUserPrompt(input, ctx) {
 			header: "Review workflow",
 			body: workflow
 		},
+		{
+			id: "pr_review.proactive_memory",
+			source: "discipline",
+			header: "Proactive memory use",
+			body: buildProactiveMemoryWorkflowBlock()
+		},
 		{
 			id: "pr_review.task_prompt",
 			source: "task_input",
@@ -26409,14 +26487,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 			});
 			return makeFailedOutput("session_setup_failed", message);
 		}
-		let llmAbort = false;
-		let llmErrorMessage = null;
-		let assistantText = "";
+		const turnState = createSessionTurnState();
 		let reporterError = null;
 		const usage = finalUsage;
 		let capAbort = null;
-		let toolUseTurnCount = 0;
-		let bashTimeoutCount = 0;
 		const maxTurns = opts.maxTurns ?? 0;
 		const maxBashTimeouts = opts.maxBashTimeouts ?? 3;
 		cancelListener = wireSessionAbort(reporter.cancelSignal, session);
@@ -26451,49 +26525,16 @@ async function executePiTask(claimedTask, reporter, opts) {
 				message
 			}));
 		};
-		session.subscribe((event) => {
-			if (event.type === "message_update") {
-				const ae = event.assistantMessageEvent;
-				if (ae.type === "text_delta") {
-					assistantText += ae.delta;
-					track(emit("text_delta", { delta: ae.delta }));
-				}
-			} else if (event.type === "tool_execution_start") track(emit("tool_call_start", { tool_name: event.toolName }));
-			else if (event.type === "tool_execution_end") {
-				track(emit("tool_call_end", {
-					tool_name: event.toolName,
-					is_error: event.isError,
-					result: event.isError ? truncateForWire(event.result) : void 0
-				}));
-				if (shouldEmitToolCallError(event)) track(emitError("tool_call_error", describeToolErrorMessage(event.result), {
-					tool: event.toolName,
-					result: truncateForWire(event.result)
-				}));
-				if (maxBashTimeouts > 0 && event.toolName === "bash" && event.isError && isBashTimeoutResult(event.result)) {
-					bashTimeoutCount += 1;
-					if (bashTimeoutCount >= maxBashTimeouts) triggerCapAbort("max_bash_timeouts_exceeded", `Aborted after ${bashTimeoutCount} bash timeouts in this attempt (cap ${maxBashTimeouts}).`);
-				}
-			} else if (event.type === "turn_end") {
-				const msg = event.message;
-				if (msg?.role === "assistant" && msg.usage) {
-					usage.inputTokens += Math.max(0, msg.usage.input ?? 0);
-					usage.outputTokens += Math.max(0, msg.usage.output ?? 0);
-					const cr = Math.max(0, msg.usage.cacheRead ?? 0);
-					const cw = Math.max(0, msg.usage.cacheWrite ?? 0);
-					if (cr) usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + cr;
-					if (cw) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + cw;
-				}
-				const stopReason = msg?.stopReason ?? "end_turn";
-				track(emit("turn_end", { stop_reason: stopReason }));
-				if (maxTurns > 0 && stopReason !== "end_turn" && stopReason !== "aborted" && stopReason !== "error") {
-					toolUseTurnCount += 1;
-					if (toolUseTurnCount >= maxTurns) triggerCapAbort("max_turns_exceeded", `Aborted after ${toolUseTurnCount} tool-use turns (cap ${maxTurns}).`);
-				}
-				llmAbort = msg?.stopReason === "error";
-				if (msg?.stopReason === "error") llmErrorMessage = typeof msg.errorMessage === "string" && msg.errorMessage.length > 0 ? msg.errorMessage : null;
-				else llmErrorMessage = null;
-			}
-		});
+		session.subscribe(makeSessionEventHandler({
+			state: turnState,
+			usage,
+			maxTurns,
+			maxBashTimeouts,
+			emit,
+			emitError,
+			track,
+			triggerCapAbort
+		}));
 		let runError = null;
 		const runPrompt = (promptText) => promptWithProviderErrorRetries({
 			session: liveSession,
@@ -26501,8 +26542,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 			cancelSignal: reporter.cancelSignal,
 			isCapAborted: () => capAbort !== null,
 			getProviderErrorState: () => ({
-				llmAbort,
-				llmErrorMessage
+				llmAbort: turnState.llmAbort,
+				llmErrorMessage: turnState.llmErrorMessage
 			}),
 			maxRetries: opts.maxProviderErrorRetries ?? 2,
 			baseDelayMs: opts.providerErrorRetryBaseDelayMs ?? 2e3,
@@ -26531,7 +26572,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 			isStopped: () => submitRepromptStopped({
 				cancelled: reporter.cancelSignal.aborted,
 				capAborted: capAbort !== null,
-				llmAbort
+				llmAbort: turnState.llmAbort
 			}),
 			onSubmitReprompt: async (event) => {
 				await emit("info", event);
@@ -26552,62 +26593,18 @@ async function executePiTask(claimedTask, reporter, opts) {
 		let parsedOutput = null;
 		let parsedOutputCid = null;
 		let parseError = null;
-		if (!runError && !llmAbort && !cancelled && !capAbort) {
-			const captured = submitToolHandle?.getCaptured() ?? null;
-			if (captured) try {
-				parsedOutput = captured;
-				parsedOutputCid = await computeJsonCid(captured);
-				recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "captured_via_tool"
-				});
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				parsedOutput = null;
-				parsedOutputCid = null;
-				parseError = {
-					code: "output_cid_compute_failed",
-					message: `Captured submit-tool output could not be canonicalized: ${message}`
-				};
-				recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "output_cid_compute_failed"
-				});
-				await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			}
-			else if (submitToolHandle) {
-				const exhausted = submitToolHandle.getExhaustedValidationFailure();
-				parseError = exhausted ?? {
-					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."
-				};
-				if (!exhausted) recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "output_missing"
-				});
-				await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			} else {
-				const parsed = await parseStructuredTaskOutput(assistantText, task.taskType, {
-					model: opts.model,
-					input: task.input
-				});
-				parsedOutput = parsed.output;
-				parsedOutputCid = parsed.outputCid;
-				parseError = parsed.error;
-				if (parseError) await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			}
+		if (!runError && !turnState.llmAbort && !cancelled && !capAbort) {
+			const captured = await captureAttemptOutput({
+				taskType: task.taskType,
+				model: opts.model,
+				input: task.input,
+				assistantText: turnState.assistantText,
+				submitToolHandle,
+				emit
+			});
+			parsedOutput = captured.output;
+			parsedOutputCid = captured.outputCid;
+			parseError = captured.error;
 		}
 		if (cancelled) return {
 			taskId: task.id,
@@ -26638,54 +26635,267 @@ async function executePiTask(claimedTask, reporter, opts) {
 				retryable: false
 			}
 		};
-		const reporterErrorSnapshot = reporterError;
-		const status = runError || llmAbort || parseError || reporterErrorSnapshot ? "failed" : "completed";
-		const errorCode = runError?.code ?? parseError?.code ?? reporterErrorSnapshot?.code ?? (llmAbort ? "llm_api_error" : void 0);
-		const errorMessage = runError?.message ?? parseError?.message ?? reporterErrorSnapshot?.message ?? (llmAbort ? llmErrorMessage ?? "LLM API error during turn" : void 0);
-		const errorRetryable = reporterErrorSnapshot && errorCode === reporterErrorSnapshot.code && errorMessage === reporterErrorSnapshot.message ? reporterErrorSnapshot.retryable ?? false : false;
-		return {
+		return buildAttemptResult({
 			taskId: task.id,
 			attemptN,
-			status,
 			output: parsedOutput,
 			outputCid: parsedOutputCid,
 			usage,
 			durationMs: Date.now() - startTime,
-			...errorCode && errorMessage ? { error: {
-				code: errorCode,
-				message: errorMessage,
-				retryable: errorRetryable
-			} } : {}
-		};
+			runError,
+			parseError,
+			reporterError,
+			llmAbort: turnState.llmAbort,
+			llmErrorMessage: turnState.llmErrorMessage
+		});
 	} catch (err) {
 		return makeFailedOutput("executor_unexpected_error", err instanceof Error ? err.message : String(err));
 	} finally {
-		if (cancelListener) reporter.cancelSignal.removeEventListener("abort", cancelListener);
-		if (session) try {
-			session.dispose();
-		} catch {}
-		if (reporterOpen) {
-			try {
-				await reporter.finalize(finalUsage);
-			} catch (err) {
-				const detail = err instanceof Error ? err.message : String(err);
-				console.error(`executePiTask: reporter.finalize() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		await cleanupAttempt({
+			cancelSignal: reporter.cancelSignal,
+			cancelListener,
+			session,
+			reporterOpen,
+			reporter,
+			finalUsage,
+			managed,
+			workspace,
+			taskId: task.id,
+			attemptN
+		});
+	}
+}
+function createSessionTurnState() {
+	return {
+		assistantText: "",
+		llmAbort: false,
+		llmErrorMessage: null,
+		toolUseTurnCount: 0,
+		bashTimeoutCount: 0
+	};
+}
+/**
+* Build the `AgentSession.subscribe` handler for one attempt: bridges pi
+* events to the reporter, accumulates token usage and assistant text, and
+* enforces the bash-timeout and tool-use-turn caps. Extracted from
+* `executePiTask` so this dense, branch-heavy logic is unit-tested against a
+* scripted event stream instead of only through a booted VM.
+*
+* The handler mutates `deps.state` and `deps.usage` in place; the caller reads
+* them after `session.prompt()` resolves (by which point `state.llmAbort`
+* holds the terminal turn's outcome — see the "last-turn wins" note below).
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+function makeSessionEventHandler(deps) {
+	const { state, usage, maxTurns, maxBashTimeouts, emit, emitError, track, triggerCapAbort } = deps;
+	return (event) => {
+		if (event.type === "message_update") {
+			const ae = event.assistantMessageEvent;
+			if (ae.type === "text_delta") {
+				state.assistantText += ae.delta;
+				track(emit("text_delta", { delta: ae.delta }));
 			}
-			try {
-				await reporter.close();
-			} catch (err) {
-				const detail = err instanceof Error ? err.message : String(err);
-				console.error(`executePiTask: reporter.close() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		} else if (event.type === "tool_execution_start") track(emit("tool_call_start", { tool_name: event.toolName }));
+		else if (event.type === "tool_execution_end") {
+			track(emit("tool_call_end", {
+				tool_name: event.toolName,
+				is_error: event.isError,
+				result: event.isError ? truncateForWire(event.result) : void 0
+			}));
+			if (shouldEmitToolCallError(event)) track(emitError("tool_call_error", describeToolErrorMessage(event.result), {
+				tool: event.toolName,
+				result: truncateForWire(event.result)
+			}));
+			if (maxBashTimeouts > 0 && event.toolName === "bash" && event.isError && isBashTimeoutResult(event.result)) {
+				state.bashTimeoutCount += 1;
+				if (state.bashTimeoutCount >= maxBashTimeouts) triggerCapAbort("max_bash_timeouts_exceeded", `Aborted after ${state.bashTimeoutCount} bash timeouts in this attempt (cap ${maxBashTimeouts}).`);
 			}
+		} else if (event.type === "turn_end") {
+			const msg = event.message;
+			if (msg?.role === "assistant" && msg.usage) {
+				usage.inputTokens += Math.max(0, msg.usage.input ?? 0);
+				usage.outputTokens += Math.max(0, msg.usage.output ?? 0);
+				const cr = Math.max(0, msg.usage.cacheRead ?? 0);
+				const cw = Math.max(0, msg.usage.cacheWrite ?? 0);
+				if (cr) usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + cr;
+				if (cw) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + cw;
+			}
+			const stopReason = msg?.stopReason ?? "end_turn";
+			track(emit("turn_end", { stop_reason: stopReason }));
+			if (maxTurns > 0 && stopReason !== "end_turn" && stopReason !== "aborted" && stopReason !== "error") {
+				state.toolUseTurnCount += 1;
+				if (state.toolUseTurnCount >= maxTurns) triggerCapAbort("max_turns_exceeded", `Aborted after ${state.toolUseTurnCount} tool-use turns (cap ${maxTurns}).`);
+			}
+			state.llmAbort = msg?.stopReason === "error";
+			if (msg?.stopReason === "error") state.llmErrorMessage = typeof msg.errorMessage === "string" && msg.errorMessage.length > 0 ? msg.errorMessage : null;
+			else state.llmErrorMessage = null;
 		}
-		if (managed) await managed.vm.close();
-		if (workspace) try {
-			workspace.cleanup();
+	};
+}
+/**
+* Resolve the attempt's structured output once the session has finished
+* cleanly (no run error / provider abort / cancel / cap). Three mutually
+* exclusive paths, in precedence order:
+*
+*   1. Submit tool captured a payload → trust it, compute its CID. A
+*      canonicalization failure becomes `output_cid_compute_failed`.
+*   2. Submit tool registered but nothing captured → the exhausted-validation
+*      failure wins if present, else `submit_output_missing` (recording the
+*      `output_missing` counter so the never-called path is observable).
+*   3. No submit tool (legacy task type) → parse the trailing assistant text.
+*
+* Extracted from `executePiTask` so this precedence — the part a refactor is
+* most likely to silently reorder — is unit-tested directly. The caller
+* still owns the guard deciding whether output capture runs at all.
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+async function captureAttemptOutput(deps) {
+	const { taskType, model, input, assistantText, submitToolHandle, emit } = deps;
+	const captured = submitToolHandle?.getCaptured() ?? null;
+	if (captured) try {
+		const outputCid = await computeJsonCid(captured);
+		recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "captured_via_tool"
+		});
+		return {
+			output: captured,
+			outputCid,
+			error: null
+		};
+	} catch (err) {
+		const error = {
+			code: "output_cid_compute_failed",
+			message: `Captured submit-tool output could not be canonicalized: ${err instanceof Error ? err.message : String(err)}`
+		};
+		recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "output_cid_compute_failed"
+		});
+		await emit("error", {
+			message: error.message,
+			phase: "output_validation"
+		});
+		return {
+			output: null,
+			outputCid: null,
+			error
+		};
+	}
+	if (submitToolHandle) {
+		const exhausted = submitToolHandle.getExhaustedValidationFailure();
+		const error = exhausted ?? {
+			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."
+		};
+		if (!exhausted) recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "output_missing"
+		});
+		await emit("error", {
+			message: error.message,
+			phase: "output_validation"
+		});
+		return {
+			output: null,
+			outputCid: null,
+			error
+		};
+	}
+	const parsed = await parseStructuredTaskOutput(assistantText, taskType, {
+		model,
+		input
+	});
+	if (parsed.error) await emit("error", {
+		message: parsed.error.message,
+		phase: "output_validation"
+	});
+	return {
+		output: parsed.output,
+		outputCid: parsed.outputCid,
+		error: parsed.error
+	};
+}
+/**
+* Assemble the terminal `TaskOutput` for a clean-or-failed finish (cancel and
+* cap aborts are handled by the caller's earlier returns). Encapsulates the
+* failure-precedence ladder — runError → parseError → reporterError →
+* provider abort — so the ordering is unit-tested rather than buried in the
+* orchestrator. A provider abort with no captured diagnostic falls back to a
+* generic message.
+*
+* Errors are non-retryable EXCEPT a reporterError that both wins the ladder
+* and set `retryable: true` (a transient reporter failure, #1538).
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+function buildAttemptResult(args) {
+	const status = args.runError || args.llmAbort || args.parseError || args.reporterError ? "failed" : "completed";
+	const errorCode = args.runError?.code ?? args.parseError?.code ?? args.reporterError?.code ?? (args.llmAbort ? "llm_api_error" : void 0);
+	const errorMessage = args.runError?.message ?? args.parseError?.message ?? args.reporterError?.message ?? (args.llmAbort ? args.llmErrorMessage ?? "LLM API error during turn" : void 0);
+	const errorRetryable = args.reporterError && errorCode === args.reporterError.code && errorMessage === args.reporterError.message ? args.reporterError.retryable ?? false : false;
+	return {
+		taskId: args.taskId,
+		attemptN: args.attemptN,
+		status,
+		output: args.output,
+		outputCid: args.outputCid,
+		usage: args.usage,
+		durationMs: args.durationMs,
+		...errorCode && errorMessage ? { error: {
+			code: errorCode,
+			message: errorMessage,
+			retryable: errorRetryable
+		} } : {}
+	};
+}
+/**
+* Tear down one attempt's resources, in order: detach the cancel listener →
+* dispose the pi session → finalize+close the reporter → close the VM →
+* clean the workspace. Extracted from `executePiTask`'s `finally` so the
+* swallow-vs-log-vs-propagate policy is pinned by tests.
+*
+* Failure handling is deliberately asymmetric and preserved exactly:
+* `session.dispose()` throws are silently swallowed; reporter finalize/close
+* and workspace cleanup failures are logged but non-fatal (the task is about
+* to be reported anyway). `vm.close()` is the one teardown error allowed to
+* propagate: a leaked VM means a live microVM the host never reclaims, so its
+* failure must surface loudly rather than be logged and forgotten.
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+async function cleanupAttempt(deps) {
+	const log = deps.logError ?? ((m) => console.error(m));
+	if (deps.cancelListener) deps.cancelSignal.removeEventListener("abort", deps.cancelListener);
+	if (deps.session) try {
+		deps.session.dispose();
+	} catch {}
+	if (deps.reporterOpen) {
+		try {
+			await deps.reporter.finalize(deps.finalUsage);
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			log(`executePiTask: reporter.finalize() failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
+		}
+		try {
+			await deps.reporter.close();
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
-			console.error(`executePiTask: workspace cleanup failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+			log(`executePiTask: reporter.close() failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
 		}
 	}
+	if (deps.managed) await deps.managed.vm.close();
+	if (deps.workspace) try {
+		deps.workspace.cleanup();
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		log(`executePiTask: workspace cleanup failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
+	}
 }
 function applyExecutionPlanSandboxOverrides(sandboxConfig, executionPlan) {
 	const shadowWrites = executionPlan?.workspaceAttachment?.shadowWrites;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "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.34.0",
-    "@themoltnet/sdk": "0.118.0"
+    "@themoltnet/agent-runtime": "0.35.0",
+    "@themoltnet/sdk": "0.119.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",