@maxiaochao/pi-toolkit 0.11.13 → 0.11.15

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 2026-10-14 - v0.11.15
+
+- openai-account-pool v0.1.5: make the current-account marker session-local and hide it until the session uses Codex
+- make the OpenAI Account Pool `●当前` marker session-local and hide it before the session uses Codex
+
+## 2026-10-14 - v0.11.14
+
+- herdr-subagents v0.5.1: fix focus-safe run cleanup and compact report output
+- fix Herdr Subagents so completed child Pi panes remain inspectable while focused and close cleanly after focus leaves, without raw ANSI fragments from forced TUI exits
+- keep large Subagent results on disk while showing compact report calls and one result path per task to the parent model
+
 ## 2026-10-14 - v0.11.13
 
 - openai-account-pool v0.1.4: hide the redundant next-session marker when it matches the current account

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-toolkit",
-  "version": "0.11.13",
+  "version": "0.11.15",
   "description": "Personal pi coding agent toolkit: scheduler, /btw, /cache_export, apply_patch, browser automation, and bundled theme/skills.",
   "type": "module",
   "workspaces": [

package/packages/herdr-subagents/ARCHITECTURE.md

@@ -80,7 +80,7 @@ There is no global dispatcher, persisted background queue, blocked response lane
 
 ## Child boundary
 
-Each task owns one Herdr pane and one single-task Pi process. Herdr first starts and detects the interactive Pi, then submits the prompt exactly once. The child extension exits the process at Pi’s final `agent_settled` boundary, giving each task an unambiguous process lifetime without parent-side prompt retries.
+Each task owns one Herdr pane and one single-task Pi process. Herdr first starts and detects the interactive Pi, then submits the prompt exactly once. At Pi’s final `agent_settled` boundary, the child extension records settled state but leaves the interactive process alive. The atomic report remains the authoritative task result. Early-finishing children remain visible while sibling tasks continue. Once the whole run settles, the orchestrator closes an unfocused owned tab immediately and defers a focused tab until the user leaves it, so Pi can restore the terminal normally.
 
 The child writes:
 

package/packages/herdr-subagents/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2026-10-14 - v0.5.1
+
+- fix focus-safe run cleanup and compact report output
+- keep settled child Pi TUIs alive until focus-aware tab cleanup, preventing abrupt exits and leaked ANSI control sequences in focused panes
+- render report submission compactly and return only each task's complete-result path to the parent model
+
 ## 2026-10-13 - v0.5.0
 
 - simplify lifecycle to one report-first state machine with strict serial and bounded read-only parallel execution

package/packages/herdr-subagents/README.md

@@ -34,7 +34,7 @@ The reproducible source recording is retained as [`docs/demo.webm`](docs/demo.we
 }
 ```
 
-Each task starts a single-task interactive Pi process in its own Herdr pane. Herdr first confirms the interactive Pi is ready, then the prompt is delivered exactly once. Prompt acknowledgement never decides task completion. Panes remain ordinary Herdr panes: they can be focused and inspected while work is running.
+Each task starts a single-task interactive Pi process in its own Herdr pane. Herdr first confirms the interactive Pi is ready, then the prompt is delivered exactly once. Prompt acknowledgement never decides task completion. Panes remain ordinary Herdr panes: they can be focused and inspected while work is running or after it settles. An early-finishing child stays at the Pi UI while sibling tasks continue. After the whole run settles, cleanup closes an unfocused run tab immediately or waits for the user to leave a focused run tab.
 
 ## Result protocol
 
@@ -45,6 +45,8 @@ The child must call `subagent_report` once with a terminal status:
 
 The complete result is stored on disk. The parent receives only the compact summary and document paths.
 
+The child UI renders only the report status and saved size instead of echoing the complete result argument. The parent-facing tool result includes one complete-result path per task; additional consulted-document metadata remains in the durable report.
+
 An atomically renamed attempt report is the authoritative completion signal. Herdr states such as `idle`, `blocked`, and `done` are wake-up hints only. A prompt transport error or Pi retry cannot fail a task while its child process remains alive. If the process exits without a valid report, the task fails explicitly.
 
 Duplicate identical reports are idempotent. A conflicting report for the same task attempt is rejected. Terminal task records are immutable.

package/packages/herdr-subagents/TESTING.md

@@ -17,7 +17,8 @@ It verifies:
 - explicit failure when the process exits without a report;
 - parent cancellation of running and queued tasks;
 - immutable terminal task records;
-- idempotent duplicate reports and rejection of conflicting replacements.
+- idempotent duplicate reports and rejection of conflicting replacements;
+- keeping a settled child alive for focus-aware cleanup instead of force-exiting its TUI.
 
 The previous broad lifecycle suite remains available temporarily as `npm run test:legacy --workspace @maxiaochao/pi-herdr-subagents` for migration auditing. Scenarios for background queues, blocked/respond, and historical resume intentionally no longer describe the public contract.
 
@@ -33,4 +34,4 @@ Run the real Herdr smoke test from a Herdr session:
 npm run test:real-herdr --workspace @maxiaochao/pi-herdr-subagents
 ```
 
-For real smoke testing, verify that each child appears in a visible pane, can be focused and inspected, exits after one terminal report, and that the parent returns only after all requested tasks settle. Also verify cancellation closes the run tab and does not overwrite a report already atomically published.
+For real smoke testing, verify that each child appears in a visible pane and can be focused and inspected. An early-finishing child must remain visible while sibling tasks continue. After the whole run settles, a focused child must remain at its restored Pi UI until focus leaves the run tab; the tab must then close automatically. Verify that the parent returns only after all requested tasks settle. Also verify cancellation closes the run tab and does not overwrite a report already atomically published.

package/packages/herdr-subagents/extensions/subagent-report.ts

@@ -3,6 +3,7 @@ import net from "node:net";
 import { dirname, resolve } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { resultPathForAttemptId } from "../src/result-path.ts";
 import { PARENT_PANE_ENV } from "../src/live-agent.ts";
@@ -75,12 +76,11 @@ export default function (pi: ExtensionAPI) {
 		const taskDirectory = process.env.PI_HERDR_SUBAGENTS_TASK_DIR?.trim();
 		if (taskDirectory && activeAttemptId) {
 			writeAttemptState(taskDirectory, activeAttemptId, "settled");
-			const reported = existsSync(attemptReportPath(taskDirectory, activeAttemptId));
-			// agent_settled is Pi's final automatic-work boundary. Ending the child here
-			// gives the orchestrator an authoritative no-report process-exit signal while
-			// still allowing all provider auto-retries to finish first.
-			setTimeout(() => process.exit(reported ? 0 : 2), 25);
 		}
+		// Keep the interactive child alive at Pi's final automatic-work boundary.
+		// The orchestrator settles each task from its atomic report. Once every task in
+		// the run settles, it closes the owned tab immediately when unfocused or waits
+		// for the user to leave it. Force-exiting here can interrupt TUI restoration.
 		if (ctx?.isIdle?.() === true) reportHerdrState("idle");
 	});
 	pi.events.on("herdr:blocked", (data: { active?: boolean; label?: string }) => {
@@ -103,6 +103,19 @@ export default function (pi: ExtensionAPI) {
 		label: "Subagent Report",
 		description: "Finish this delegated task by saving its complete result and returning only a compact structured report to the parent.",
 		parameters: ReportParams,
+		renderCall(params, theme) {
+			const resultBytes = Buffer.byteLength(params.result, "utf8");
+			const size = resultBytes < 1024 ? `${resultBytes} B` : `${(resultBytes / 1024).toFixed(1)} KiB`;
+			return new Text(`${theme.fg("toolTitle", theme.bold("subagent_report "))}${theme.fg(params.status === "completed" ? "success" : "error", params.status)}${theme.fg("dim", ` · ${size} saved to disk`)}`, 0, 0);
+		},
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Saving report..."), 0, 0);
+			const report = result.details as { status?: string; summary?: string; documents?: Array<{ path?: string }> } | undefined;
+			const resultPath = report?.documents?.[0]?.path;
+			const status = report?.status ?? "saved";
+			const summary = report?.summary?.replaceAll("\n", " ") ?? "Report saved.";
+			return new Text(`${theme.fg(status === "completed" ? "success" : status === "failed" ? "error" : "accent", status)}${theme.fg("dim", ` · ${summary}${resultPath ? `\n${resultPath}` : ""}`)}`, 0, 0);
+		},
 		async execute(_toolCallId, params) {
 			const taskDirectory = process.env.PI_HERDR_SUBAGENTS_TASK_DIR?.trim();
 			if (!taskDirectory) throw new Error("PI_HERDR_SUBAGENTS_TASK_DIR is not set");

package/packages/herdr-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxiaochao/pi-herdr-subagents",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Run inspectable interactive Pi subagent batches through Herdr.",
   "type": "module",
   "keywords": [

package/packages/herdr-subagents/src/tool.ts

@@ -159,8 +159,12 @@ async function executeBatch({ params, signal, onUpdate, ctx, dependencies, disco
 			onCleanupError: (text) => onUpdate?.({ content: [{ type: "text", text }], details: { action: "batch", runId: dependencies.runId, cleanupError: text } }),
 			onUpdate: (partial) => onUpdate?.({ content: [{ type: "text", text: partial.summary }], details: { ...partial, prompts: tasks.map((task) => task.prompt) } }),
 		});
-		const lines = [result.summary, ...result.tasks.map((task) => `- ${task.name}: ${task.status} — ${task.summary}`)];
-		if (result.documents.length) lines.push("", "Documents:", ...result.documents.map((document) => `- ${document.description}: ${document.path}`));
+		const lines = [result.summary];
+		for (const task of result.tasks) {
+			lines.push(`- ${task.name}: ${task.status} — ${task.summary}`);
+			const resultDocument = task.documents[0];
+			if (resultDocument) lines.push(`  Result: ${resultDocument.path}`);
+		}
 		const isError = result.status === "failed" || result.status === "partial" || result.status === "cancelled";
 		return { content: [{ type: "text", text: lines.join("\n") }], details: { ...result, prompts: tasks.map((task) => task.prompt) }, ...(isError ? { isError: true } : {}) };
 	} catch (error) {

package/packages/herdr-subagents/tests/core-state-machine.mjs

@@ -170,6 +170,24 @@ assert.throws(() => applyTaskStatus(terminal, "running"), /terminal tasks are im
 	await reportTool.execute("first", report);
 	await reportTool.execute("duplicate", report);
 	await assert.rejects(() => reportTool.execute("conflict", { ...report, summary: "different" }), /Conflicting subagent_report/);
+	const originalExit = process.exit;
+	let exitCode;
+	process.exit = (code) => { exitCode = code; };
+	try {
+		await handlers.get("agent_settled")?.({}, { isIdle: () => true });
+		await new Promise((resolve) => setTimeout(resolve, 40));
+	} finally {
+		process.exit = originalExit;
+	}
+	assert.equal(exitCode, undefined, "settled child must remain alive for focus-aware tab cleanup");
+	const attempt = JSON.parse(readFileSync(join(directory, "attempts", `${attemptId}.json`), "utf8"));
+	assert.equal(attempt.state, "settled");
+	const theme = { fg: (_color, text) => text, bold: (text) => text };
+	const renderedCall = reportTool.renderCall({ ...report, result: "FULL RESULT MUST NOT RENDER" }, theme).render(120).join("\n");
+	assert.match(renderedCall, /completed.*saved to disk/);
+	assert.doesNotMatch(renderedCall, /FULL RESULT MUST NOT RENDER/);
+	const renderedResult = reportTool.renderResult(await reportTool.execute("render", report), { isPartial: false }, theme).render(120).join("\n");
+	assert.match(renderedResult, /completed.*done/);
 	const persisted = JSON.parse(readFileSync(join(directory, "reports", `${attemptId}.json`), "utf8"));
 	assert.equal(persisted.summary, "done");
 	delete process.env.PI_HERDR_SUBAGENTS_TASK_DIR;