@gavin-hu/my-pi-agent 0.16.0 → 0.18.0

package/extensions/file-browse/tree.ts

@@ -0,0 +1,381 @@
+/**
+ * The browse page's sidebar: the path filter, the fold-all control, the lazy
+ * tree, and the tree's keyboard model.
+ *
+ * It is a fragment of the same IIFE `client.ts` ships (`TREE_CLIENT_JS` is
+ * interpolated into `CLIENT_JS`), kept in its own module because the sidebar is
+ * one concern with its own state: the filter query, each folder's `data-open`
+ * intent, and the one row the keyboard is on.
+ */
+
+import { SIDEBAR_COLLAPSE_MAX } from "../../lib/web/index.ts";
+
+export const TREE_CLIENT_JS = `	var tree = document.querySelector("nav.bf-tree");
+	var filter = document.getElementById("filter");
+	var foldAllButton = document.getElementById("fold-all");
+	var query = "";
+
+	function matches(text) {
+		return !query || text.toLowerCase().indexOf(query) !== -1;
+	}
+
+	// A row is found from inside it (an event target) or from its own list item:
+	// closest() only looks upwards, so paint() cannot start from the li.
+	function rowOf(node) {
+		var row = node && node.closest ? node.closest(".bf-tree__row") : null;
+		return row && tree && tree.contains(row) ? row : null;
+	}
+
+	function rowFor(li) {
+		return li ? li.querySelector(":scope > .bf-tree__row") : null;
+	}
+
+	function rowLink(row) {
+		return row ? row.querySelector("a") : null;
+	}
+
+	var SVG_NS = "http://www.w3.org/2000/svg";
+
+	function svgIcon(entry) {
+		var svg = document.createElementNS(SVG_NS, "svg");
+		svg.setAttribute("class", "browse-cat " + (entry.colorClass || ""));
+		svg.setAttribute("aria-hidden", "true");
+		svg.setAttribute("title", entry.label || "");
+		var use = document.createElementNS(SVG_NS, "use");
+		use.setAttribute("href", entry.iconHref);
+		svg.appendChild(use);
+		return svg;
+	}
+
+	function buildNode(entry) {
+		var li = document.createElement("li");
+		var row = document.createElement("div");
+		row.className = "bf-tree__row";
+		row.setAttribute("data-path", entry.path || "");
+		var twisty = document.createElement(entry.isDir ? "button" : "span");
+		twisty.className = "bf-tree__tw";
+		row.appendChild(twisty);
+		row.appendChild(svgIcon(entry));
+		if (entry.isDir) {
+			li.dataset.open = "false";
+			twisty.classList.add("bf-tree__tw--toggle");
+			twisty.type = "button";
+			twisty.tabIndex = -1;
+			twisty.setAttribute("aria-hidden", "true");
+			twisty.textContent = "\\u25B8";
+			var dir = document.createElement("a");
+			dir.href = entry.href;
+			dir.tabIndex = -1;
+			dir.setAttribute("aria-expanded", "false");
+			dir.textContent = entry.name + "/";
+			row.appendChild(dir);
+		} else if (entry.broken) {
+			twisty.className = "bf-tree__tw bf-tree__tw--spacer";
+			twisty.setAttribute("aria-hidden", "true");
+			var broken = document.createElement("span");
+			broken.className = "browse-broken";
+			broken.title = "broken symbolic link";
+			broken.textContent = entry.name;
+			row.appendChild(broken);
+			var mark = document.createElement("span");
+			mark.className = "browse-link-mark";
+			mark.textContent = "\\u21A9";
+			row.appendChild(mark);
+		} else {
+			twisty.className = "bf-tree__tw bf-tree__tw--spacer";
+			twisty.setAttribute("aria-hidden", "true");
+			var file = document.createElement("a");
+			file.href = entry.href;
+			file.tabIndex = -1;
+			file.textContent = entry.name;
+			row.appendChild(file);
+		}
+		li.appendChild(row);
+		return li;
+	}
+
+	function filterNode(li) {
+		var row = li.querySelector(":scope > .bf-tree__row");
+		var own = matches(row ? row.getAttribute("data-path") || row.textContent : "");
+		var childMatch = false;
+		Array.prototype.forEach.call(li.querySelectorAll(":scope > ul > li"), function (child) {
+			if (filterNode(child)) childMatch = true;
+		});
+		var visible = own || childMatch;
+		li.hidden = !visible;
+		return visible;
+	}
+
+	function applyFilter() {
+		var empty = document.getElementById("tree-empty");
+		var anyTree = false;
+		if (tree) {
+			Array.prototype.forEach.call(tree.querySelectorAll(":scope > ul > li"), function (li) {
+				if (filterNode(li)) anyTree = true;
+			});
+		}
+		if (empty) empty.hidden = !tree || anyTree;
+		Array.prototype.forEach.call(document.querySelectorAll("table.bf-table tbody tr"), function (row) {
+			var path = row.getAttribute("data-path") || row.getAttribute("data-name") || "";
+			row.hidden = !matches(path);
+		});
+		// Lists are repainted too: while a query is active every list is shown, and
+		// clearing the query brings the folds back.
+		if (tree) Array.prototype.forEach.call(tree.querySelectorAll("li[data-open]"), paint);
+	}
+
+	if (filter) {
+		filter.addEventListener("input", function () {
+			query = filter.value.trim().toLowerCase();
+			applyFilter();
+		});
+	}
+
+	// Visibility is derived: the intent in data-open, opened up while a filter is
+	// active so a fold cannot hide a match.
+	function isOpen(li) {
+		return query !== "" || li.dataset.open === "true";
+	}
+
+	function paint(li) {
+		var row = rowFor(li);
+		var twisty = row ? row.querySelector(":scope > .bf-tree__tw") : null;
+		if (!twisty || twisty.tagName !== "BUTTON") return;
+		var open = isOpen(li);
+		// A pending load owns the glyph until it lands or fails.
+		if (!li.dataset.loading && !li.dataset.error) twisty.textContent = open ? "\\u25BE" : "\\u25B8";
+		var link = rowLink(row);
+		if (link) link.setAttribute("aria-expanded", open ? "true" : "false");
+		var list = li.querySelector(":scope > ul");
+		if (list) list.hidden = !open;
+	}
+
+	function setOpen(li, open) {
+		li.dataset.open = open ? "true" : "false";
+		paint(li);
+	}
+
+	// Every dir with rendered children: what the fold-all control acts on.
+	function foldableDirs() {
+		var dirs = [];
+		if (!tree) return dirs;
+		Array.prototype.forEach.call(tree.querySelectorAll("li"), function (li) {
+			if (li.querySelector(":scope > ul")) dirs.push(li);
+		});
+		return dirs;
+	}
+
+	function syncFoldButton() {
+		if (!foldAllButton) return;
+		var dirs = foldableDirs();
+		var open = 0;
+		dirs.forEach(function (li) {
+			if (li.dataset.open === "true") open++;
+		});
+		foldAllButton.hidden = dirs.length === 0;
+		foldAllButton.textContent = open > 0 ? "fold all" : "expand all";
+	}
+
+	function setAll(open) {
+		foldableDirs().forEach(function (li) {
+			setOpen(li, open);
+		});
+		syncFoldButton();
+	}
+
+	function loadChildren(li, twisty, path) {
+		var link = rowLink(rowFor(li));
+		var name = link ? link.textContent.slice(0, -1) : path;
+		li.dataset.loading = "true";
+		twisty.textContent = "\\u2026";
+		if (link) link.setAttribute("aria-busy", "true");
+		fetch("/api/tree?path=" + encodeURIComponent(path))
+			.then(function (response) {
+				if (!response.ok) throw new Error("load failed");
+				return response.json();
+			})
+			.then(function (data) {
+				var built = document.createElement("ul");
+				(data.entries || []).forEach(function (entry) {
+					built.appendChild(buildNode(entry));
+				});
+				li.appendChild(built);
+				delete li.dataset.loading;
+				delete li.dataset.error;
+				setOpen(li, true);
+				if (link) link.setAttribute("aria-busy", "false");
+				applyFilter();
+			})
+			.catch(function () {
+				delete li.dataset.loading;
+				li.dataset.error = "true";
+				li.dataset.open = "false";
+				twisty.textContent = "\\u26A0";
+				twisty.title = "Could not load " + name + ". Press to retry.";
+				if (link) {
+					link.setAttribute("aria-busy", "false");
+					link.setAttribute("aria-expanded", "false");
+				}
+			});
+	}
+
+	if (tree) {
+		tree.addEventListener("click", function (event) {
+			var twisty = event.target.closest(".bf-tree__tw");
+			if (!twisty || twisty.tagName !== "BUTTON" || !tree.contains(twisty)) return;
+			event.preventDefault();
+			var li = twisty.closest("li");
+			if (!li) return;
+			var list = li.querySelector(":scope > ul");
+			if (li.dataset.open === "true") {
+				setOpen(li, false);
+				return;
+			}
+			if (list) {
+				setOpen(li, true);
+				applyFilter();
+				return;
+			}
+			var row = li.querySelector(":scope > .bf-tree__row");
+			var path = row ? row.getAttribute("data-path") : null;
+			if (!path) return;
+			loadChildren(li, twisty, path);
+		});
+	}
+
+	// The tree is one tab stop. Arrows move between the rows a reader can see,
+	// Right opens a folder (reading it first when it has never been loaded),
+	// Left closes it or steps out to the parent, Space toggles, and Enter follows
+	// the focused link itself — the row is a link, so the browser owns activation.
+	function treeRows() {
+		return tree ? Array.prototype.slice.call(tree.querySelectorAll(".bf-tree__row")) : [];
+	}
+
+	function visibleRows() {
+		return treeRows().filter(function (row) { return row.getClientRects().length > 0; });
+	}
+
+	function setTabStop(row) {
+		treeRows().forEach(function (other) {
+			var link = rowLink(other);
+			if (link) link.tabIndex = other === row ? 0 : -1;
+		});
+	}
+
+	function focusRow(row) {
+		if (!row) return;
+		setTabStop(row);
+		var link = rowLink(row);
+		if (link) link.focus();
+	}
+
+	function moveFocus(row, delta) {
+		var rows = visibleRows();
+		var at = rows.indexOf(row);
+		if (at >= 0) focusRow(rows[at + delta]);
+	}
+
+	function parentRowOf(row) {
+		var li = row.parentNode;
+		var list = li ? li.parentNode : null;
+		var parentLi = list && list.closest ? list.closest("li") : null;
+		return parentLi ? parentLi.querySelector(":scope > .bf-tree__row") : null;
+	}
+
+	// A folder that has never been expanded has no child list yet; opening it is
+	// the same request the twisty makes, so the keyboard reuses it.
+	function openFolder(row) {
+		var li = row.parentNode;
+		var twisty = row.querySelector(".bf-tree__tw--toggle");
+		if (!li || !twisty) return null;
+		var list = li.querySelector(":scope > ul");
+		if (list) return list;
+		var path = row.getAttribute("data-path");
+		if (path) loadChildren(li, twisty, path);
+		return null;
+	}
+
+	function expandRow(row) {
+		var li = row.parentNode;
+		if (!li || !row.querySelector(".bf-tree__tw--toggle")) return;
+		var list = openFolder(row);
+		if (!list) return;
+		if (!isOpen(li)) {
+			setOpen(li, true);
+			applyFilter();
+			return;
+		}
+		var rows = visibleRows();
+		var next = rows[rows.indexOf(row) + 1];
+		if (next && parentRowOf(next) === row) focusRow(next);
+	}
+
+	function collapseRow(row) {
+		var li = row.parentNode;
+		if (li && li.querySelector(":scope > ul") && isOpen(li)) {
+			setOpen(li, false);
+			applyFilter();
+			return;
+		}
+		focusRow(parentRowOf(row));
+	}
+
+	function toggleRow(row) {
+		var li = row.parentNode;
+		if (!li || !row.querySelector(".bf-tree__tw--toggle")) return;
+		if (!openFolder(row)) return;
+		setOpen(li, li.dataset.open !== "true");
+		applyFilter();
+	}
+
+	if (tree) {
+		tree.addEventListener("keydown", function (event) {
+			var row = rowOf(event.target);
+			if (!row || event.metaKey || event.ctrlKey || event.altKey) return;
+			var rows = visibleRows();
+			if (event.key === "ArrowDown") moveFocus(row, 1);
+			else if (event.key === "ArrowUp") moveFocus(row, -1);
+			else if (event.key === "Home") focusRow(rows[0]);
+			else if (event.key === "End") focusRow(rows[rows.length - 1]);
+			else if (event.key === "ArrowRight") expandRow(row);
+			else if (event.key === "ArrowLeft") collapseRow(row);
+			else if (event.key === " " && row.querySelector(".bf-tree__tw--toggle")) toggleRow(row);
+			else return;
+			// The page keymap treats a bare key as its own; the tree keeps its own.
+			event.preventDefault();
+			event.stopPropagation();
+		});
+		// A pointer click lands on one row, so that row becomes the tab stop the
+		// next Tab returns to.
+		tree.addEventListener("focusin", function (event) {
+			var row = rowOf(event.target);
+			if (row) setTabStop(row);
+		});
+	}
+
+	// The current page's row, else the first one, is the way into the tree.
+	setTabStop(tree && tree.querySelector(".bf-tree__row[aria-current]") || (tree ? treeRows()[0] : null));
+
+	var panel = document.querySelector("details.bf-app__sidebar");
+	if (panel && window.matchMedia) {
+		var mq = window.matchMedia("(max-width: ${SIDEBAR_COLLAPSE_MAX}px)");
+		var syncSide = function () { panel.open = !mq.matches; };
+		syncSide();
+		if (mq.addEventListener) mq.addEventListener("change", syncSide);
+		else if (mq.addListener) mq.addListener(syncSide);
+	}
+
+	if (foldAllButton) {
+		foldAllButton.addEventListener("click", function () {
+			// The control folds when anything is open, and expands when nothing is.
+			var open = false;
+			foldableDirs().forEach(function (li) {
+				if (li.dataset.open === "true") open = true;
+			});
+			setAll(!open);
+		});
+	}
+
+	// The control starts in the state the rendered tree implies.
+	syncFoldButton();
+`;

package/extensions/file-read/README.md

@@ -201,7 +201,10 @@ config defaults, and error listing all derive from it.
 2. Add `extensions/file-read/extract/<fmt>.ts` exporting a `FormatExtractor` that
    `await import(...)`s its library, reads the bytes with `readFormatBytes`, and
    normalizes the output. Keep the parsing in a pure, exported helper so it is
-   testable without a real file.
+   testable without a real file. **The import goes inside the function**, not at
+   module scope: `formats.ts` imports every extractor when the tool registers, so
+   a module-scope import loads that library on every start — `test/dependencies.test.ts`
+   fails on exactly that.
 3. Add a `ReadFormat` entry to `FORMATS` and widen the `id` union.
 4. Add the new extractor to `extract/extract.test.ts` with a real minimal
    fixture, and extend `tool.test.ts` for format selection and config.

package/extensions/file-read/extract/odt.ts

@@ -5,11 +5,11 @@
  * unzips it with `fflate`, parses the XML with `fast-xml-parser`, and walks the
  * body for text: paragraphs and headings become lines, table cells are
  * tab-separated, and `text:s` / `text:tab` / `text:line-break` become their
- * whitespace. The walk over the parsed tree is pure and tested directly.
+ * whitespace. Both libraries load on the first ODT read, never at registration,
+ * so a session that never opens one pays nothing for them; the walk over the
+ * parsed tree is pure and tested directly.
  */
 
-import { strFromU8, unzipSync } from "fflate";
-import { XMLParser } from "fast-xml-parser";
 import { normalizeBodyText, readFormatBytes, type FormatExtractor } from "./file.ts";
 
 /** Elements that end a line. */
@@ -68,12 +68,13 @@ function collect(nodes: unknown, out: string[], inText: boolean): void {
 }
 
 /**
- * Extract plain text from the body of an ODT `content.xml`. Pure.
+ * Extract plain text from the body of an ODT `content.xml`.
  *
  * Trailing tabs and spaces at line ends, runs of blank lines, and the final
  * newline are stripped so the tool's paging sees ordinary text.
  */
-export function odtXmlToText(xml: string): string {
+export async function odtXmlToText(xml: string): Promise<string> {
+	const { XMLParser } = await import("fast-xml-parser");
 	const parser = new XMLParser({
 		preserveOrder: true,
 		ignoreAttributes: false,
@@ -94,6 +95,7 @@ export function odtXmlToText(xml: string): string {
 
 /** Extract the body text from an ODT file. */
 export const extractOdtText: FormatExtractor = async (file) => {
+	const { strFromU8, unzipSync } = await import("fflate");
 	const archive = unzipSync(await readFormatBytes(file));
 	const content = archive["content.xml"];
 	if (!content) throw new Error("ODT archive has no content.xml.");

package/extensions/goal/plan-route.ts

@@ -19,7 +19,8 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isPursuedGoal } from "../../lib/goal-state.ts";
-import { PLAN_CONSENT, requestPlanMode } from "../../lib/plan-entry.ts";
+import { isRemoteTurn, remoteLanguage } from "../../lib/interaction.ts";
+import { PLAN_CONSENT, PLAN_CONSENT_SHORT, PLAN_CONSENT_SHORT_ZH, requestPlanMode } from "../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../lib/plan-state.ts";
 import { PLAN_ENTER_TOOL } from "../../lib/tool-names.ts";
 import type { Goal, GoalStatus } from "./types.ts";
@@ -45,7 +46,12 @@ export async function goalPhase(
 	if (!options.ask || !ctx.hasUI) return "active";
 	// Do not ask about a phase this session cannot enter.
 	if (!pi.getAllTools().some((tool) => tool.name === PLAN_ENTER_TOOL)) return "active";
-	const approved = await ctx.ui.confirm(PLAN_ASK, PLAN_CONSENT);
+	const consent = isRemoteTurn(ctx)
+		? remoteLanguage(ctx) === "zh"
+			? PLAN_CONSENT_SHORT_ZH
+			: PLAN_CONSENT_SHORT
+		: PLAN_CONSENT;
+	const approved = await ctx.ui.confirm(PLAN_ASK, consent);
 	if (!approved) return "active";
 	return (await requestPlanMode(pi, ctx)) ? "planning" : "active";
 }

package/extensions/goal/tools.ts

@@ -10,6 +10,7 @@
 import type { JsonValue } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { GOAL_TOOL } from "../../lib/tool-names.ts";
+import { failedResult, textResult } from "../../lib/tool-result.ts";
 import { callLine, detailsOrLine } from "../../lib/tui/tool.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
 import { paint } from "../../lib/tui/tokens.ts";
@@ -52,17 +53,11 @@ function toStructuredContent(details: GoalDetails): Record<string, JsonValue> {
  */
 function goalResult(details: GoalDetails, options: { error?: string; openTodos?: number } = {}) {
 	const { error, openTodos = 0 } = options;
-	return {
-		content: [
-			{
-				type: "text" as const,
-				text: error === undefined ? formatGoalText(details.goal, openTodos) : `Error: ${error}`,
-			},
-		],
-		details,
-		structuredContent: toStructuredContent(details),
-		...(error === undefined ? {} : { isError: true as const }),
-	};
+	const text = error === undefined ? formatGoalText(details.goal, openTodos) : `Error: ${error}`;
+	const structuredContent = toStructuredContent(details);
+	return error === undefined
+		? textResult(text, details, structuredContent)
+		: failedResult(text, details, structuredContent);
 }
 
 export function registerTools(pi: ExtensionAPI, runtime: GoalRuntime): void {

package/extensions/job/README.md

@@ -37,7 +37,8 @@ How the `job` call and its result look in the transcript — the call line as a
   chip for this session's jobs, plus a `/jobs` screen for selecting, tailing,
   killing, and clearing.
 - Reports finished jobs to the model at the start of the next turn, or — for
-  jobs started with `wake: true` — by triggering one turn.
+  jobs started with `wake: true` — by triggering one turn as soon as the agent is
+  idle, including right after a running turn settles.
 - Kills session-owned jobs on shutdown so no process is left behind; on POSIX,
   start a job with `detached: true` to keep it running and reattach next session.
   A detached job points its own output straight at its log file, so it keeps
@@ -338,13 +339,14 @@ rewritten.
   extension keeps only what is job-shaped — the durable registry, rotation,
   stdin, and the job vocabulary. The report coordinator is also why a wake can
   never stack two turns: it owns the guard for the window between the triggered
-  send and `agent_start`.
+  send and `agent_start`, and it retries a wake the running turn suppressed.
 - **Notify by default, wake opt-in.** A failed job raises one `ctx.ui.notify`
   (a clean exit is left to the list and chips). Finished jobs are also posted
   as a shared transcript notice — model-facing text plus the notice block — at the
-  next `before_agent_start`. A `wake: true` job (or `wakeOnFinish`) additionally
-  triggers one turn when the agent is idle; auto-wake is not the default because
-  it easily loops and burns tokens.
+  next `before_agent_start`, or in the wake turn it raises. A `wake: true` job (or
+  `wakeOnFinish`) additionally triggers one turn as soon as the agent is idle,
+  including right after a running turn settles; auto-wake is not the default
+  because it easily loops and burns tokens.
 - **Width-1 glyphs and cached latest line.** The running chip is `▸ N` and the
   failure chip `✗ N`, each a two-token badge under its own status key, so the
   status bar compacts each independently (`▸N` / `✗N`) and an unreported

package/extensions/job/index.ts

@@ -5,7 +5,8 @@
  * processes with their output streamed to log files; the status chip shows
  * running and unreported-failure counts, and finished jobs are reported to the
  * model — and shown as a bytefly notice — at the next turn, or by triggering one
- * turn for a `wake` job.
+ * turn for a `wake` job as soon as the agent is idle, including right after a
+ * running turn settles.
  *
  * Load with:  pi --extension ./extensions/job
  */
@@ -13,8 +14,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { JOB_FINISHED_CHANNEL, type JobFinishedEvent } from "../../lib/events.ts";
-import { noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
-import { createPendingReporter } from "../../lib/report.ts";
+import { burstText, noticeMessage, type NoticeMessage } from "../../lib/notice.ts";
+import { createPendingReporter, registerPendingChannel } from "../../lib/report.ts";
 import { registerCommands } from "./commands.ts";
 import { formatCompletion, jobOutcome, shortLabel } from "./format.ts";
 import { createJobsRuntime, type JobsRuntime } from "./runtime.ts";
@@ -25,8 +26,13 @@ import type { JobRecord } from "./types.ts";
 const JOB_CONTEXT_MARKER = "[BACKGROUND JOBS]";
 
 function buildContext(jobs: JobRecord[]): string {
-	const lines = jobs.map((job) => formatCompletion(job));
-	return `${JOB_CONTEXT_MARKER}\n${jobs.length} background job${jobs.length === 1 ? "" : "s"} finished:\n${lines.join("\n")}\nRun \`job logs <id>\` for output.`;
+	const count = jobs.length;
+	return burstText({
+		marker: JOB_CONTEXT_MARKER,
+		headline: `${count} background job${count === 1 ? "" : "s"} finished`,
+		lines: jobs.map((job) => formatCompletion(job)),
+		hint: "Run `job logs <id>` for output.",
+	});
 }
 
 /** The shared notice for pending completions: model text plus renderer details. */
@@ -66,65 +72,42 @@ export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 	if (!isExtensionEnabled("job")) return;
 	const runtime = deps.runtime ?? createJobsRuntime();
 
-	// Opt-in wake: a `wake` job finished while the agent is idle. The reporter
-	// reports *all* pending completions, not just the waking one, so a job that
-	// finished earlier is not silently marked seen and dropped.
+	// Opt-in wake: a `wake` job finished. The reporter reports *all* pending
+	// completions, not just the waking one, so a job that finished earlier is not
+	// silently marked seen and dropped, and it retries a completion that arrived
+	// mid-turn once the run settles.
 	const reporter = createPendingReporter<JobRecord>({
 		wake: (notice) => pi.sendMessage(notice, { triggerTurn: true }),
 		pending: () => runtime.pendingCompletions(),
 		markReported: (records) => runtime.markReported(records.map((job) => job.id)),
 		buildNotice: jobNotice,
 		source: "job",
+		wakeRequested: () => runtime.pendingCompletions().some((job) => job.wake),
 	});
 
 	registerTools(pi, runtime);
 	registerCommands(pi, runtime);
 
-	pi.on("session_start", (_event, ctx) => {
-		reporter.sessionStart();
-		runtime.load(ctx);
+	registerPendingChannel(pi, {
+		reporter,
+		runtime,
 		// `shutdown` clears these; a reload or session replacement reuses the
 		// runtime, so re-arm them on every session start.
-		runtime.onFinish = () => reporter.report();
-		// Notify-listening extensions follow completions on the shared bus; the
-		// runtime only knows the callback, never the channel.
-		runtime.onComplete = (job) => {
-			try {
-				pi.events.emit(JOB_FINISHED_CHANNEL, toFinishedEvent(job));
-			} catch {
-				// The event bus is optional.
-			}
-		};
-	});
-
-	// Tree navigation does not change the process table; only repaint.
-	pi.on("session_tree", (_event, ctx) => {
-		runtime.setStatus(ctx);
-	});
-
-	pi.on("agent_start", () => {
-		reporter.agentStart();
-	});
-	pi.on("agent_settled", () => {
-		reporter.agentSettled();
-	});
-
-	// Report completions to the model at the start of the next turn.
-	pi.on("before_agent_start", (_event, ctx) => {
-		const reported = reporter.beforeAgentStart();
-		if (!reported) return undefined;
-		runtime.setStatus(ctx);
-		return reported;
-	});
-
-	// Keep stale completion notices out of later turns. Only this extension's
-	// notices are pruned; another source's are left for its own handler.
-	pi.on("context", (event) => reporter.filterContext(event.messages));
-
-	// `shutdown` detaches the UI controller, which clears both chips.
-	pi.on("session_shutdown", async () => {
-		runtime.onFinish = undefined;
-		runtime.onComplete = undefined;
-		await runtime.shutdown();
+		onSessionStart: () => {
+			runtime.onFinish = () => reporter.report();
+			// Notify-listening extensions follow completions on the shared bus; the
+			// runtime only knows the callback, never the channel.
+			runtime.onComplete = (job) => {
+				try {
+					pi.events.emit(JOB_FINISHED_CHANNEL, toFinishedEvent(job));
+				} catch {
+					// The event bus is optional.
+				}
+			};
+		},
+		onSessionShutdown: () => {
+			runtime.onFinish = undefined;
+			runtime.onComplete = undefined;
+		},
 	});
 }