pi-mono-btw 1.7.0 → 1.7.4

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # pi-mono-btw
 
+## 1.7.4
+
+### Patch Changes
+
+### Maintenance
+
+- Update pi core imports and peer dependencies to the new `@earendil-works` package scope.
+
+## 1.7.3
+
+### Patch Changes
+
+### Enhanced: btw
+
+- Show `/btw` answers in a focused, dismissible panel with `Esc`/`Enter` close, `↑`/`↓` scrolling, and `x` history clearing.
+- Stop injecting completed `/btw` answers into the visible transcript; hide legacy `btw-answer` messages from older versions.
+
+## 1.7.2
+
+### Patch Changes
+
+### Fixed: ask-user-question
+
+- Remove unused `StringEnum` import from `@earendil-works/pi-ai`.
+
+## 1.7.1
+
+### Patch Changes
+
+### Fixed: team-mode
+
+- Widget no longer mislabels blocked or approval-pending teams as "running smoothly" — blockers and pending approvals are now detected via team summaries.
+- Preserve in-flight work on re-emitted `session_start` events instead of tearing the runtime down and SIGTERM-ing live teammates.
+- Auto-relaunch leaders for `running` teams after a session reset; surface failures as both a team signal and a UI notification.
+- `createTeam` now defaults `repoRoots` to `[process.cwd()]` when the caller passes an empty array.
+- Archive `process.json` into `history/` before a new task reuses the same role slot, so the prior task's final state is no longer silently clobbered.
+
+### Enhanced: team-mode
+
+- Durable intent queue for subprocess handoff: `team_spawn_teammate` calls made from a teammate subprocess are written to disk and executed by the main session's `LeaderRuntime` instead of spawning orphaned grand-children.
+- New tool `team_task_create_batch` lets the leader emit the full initial task DAG in one call, removing per-task LLM round-trips during bootstrap.
+- `team_create` / `launchLeader` accept an `awaitBootstrap` option so the user sees the task graph before the tool returns; leader launch retries up to 3 times on transient failures.
+- Persist per-turn debug artifacts (prompt, invocation, stderr, raw event stream) for both leader and teammate subprocesses, exposed via `TeammateSummary.debugArtifacts`.
+- Track `exitCode`, `exitSignal`, `terminationReason`, `stderrTail`, `toolExecutions`, `model` and `modelProvider` on every `TeammateProcess` record.
+- Provider detection now consults pi's `settings.json` and `auth.json` in addition to env vars; default model IDs aligned with the provider/model scheme.
+- `collectPiOutput` supports `AbortSignal` cancellation.
+
+### Tests
+
+- New `intent-queue` and `model-config` suites; expanded coverage across `leader-runtime`, `team-manager`, `team-query-tool` and `formatters`.
+
 ## 1.7.0
 
 ### Minor Changes
@@ -10,7 +61,22 @@
 
 ### Enhanced: team-mode
 
+- **LLM-driven leader** — replaced the hardcoded `research → synthesis → implementation → verification` state machine with a pi subprocess coordinator that authors the task graph via tool calls
+- **New tool `team_task_create`** so the leader can author tasks at runtime
+- **New tool `team_handoff`** for explicit teammate → teammate context handoffs (replaces regex-scraping of `Handoffs:` output sections)
+- **File-based teammate specs** — drop `.claude/teammates/<role>.md` frontmatter files (`name`, `description`, `needsWorktree`, `hasMemory`, `modelTier`) to extend or override the seven built-in roles
+- **Event-driven leader wakes** — mailbox messages addressed to the leader (or broadcast) trigger a debounced (~200ms) cycle instead of waiting for the 20s polling tick
+- **Templates accept any string** — `fullstack` / `research` / `refactor` remain as built-ins, but unknown template keys are accepted and no-op gracefully
+- **Provider config per team** — per-team model overrides via `/team models`
 - Reduced leader overhead and parent-session token churn
+- `spawnTeammate` now always appends the full runtime-built context (signals, mailbox, dependencies, team memory) so teammates get the richer snapshot even when the caller's `context` argument is brief
+
+### Breaking changes: team-mode
+
+- Removed `LeaderPhase` enum and `currentPhase` field from `TeamRecord` / `TeamSummary`
+- Removed `parseExplicitHandoffs` export and the legacy `Handoffs:` output parser — peer handoffs must go through the `team_handoff` tool
+- Removed the deterministic auto-spawn loop (`ensureBootstrapTasks`) — all task authoring and teammate spawning is now the LLM leader's responsibility
+- Removed `StringEnum` gate on `team_create`'s `template` parameter (now plain string)
 
 ### Fixed: review
 
@@ -20,6 +86,7 @@
 ### Documentation
 
 - Updated root README and sentinel extension README
+- Documented the new file-based teammate spec format and event-driven leader wake in the team-mode README
 
 ## 1.6.0
 
@@ -66,7 +133,6 @@ Replaced the `grep` extension with a new security-focused `sentinel` extension f
 - ### `multi-edit` — diverge from upstream fork
 
   The extension was originally derived from [mitsuhiko/agent-stuff](https://github.com/mitsuhiko/agent-stuff)'s `pi-extensions/multi-edit.ts`. This release rewrites the largest unmodified subsystems so the implementation is structurally distinct from upstream while keeping the public contract intact.
-
   - **Modularized layout** — the 953-line `index.ts` is split into purpose-scoped modules: `types.ts`, `workspace.ts`, `classic.ts`, `patch.ts`, `diff.ts`, and a slim `index.ts` (~180 lines of registration + dispatch wiring).
   - **New patch engine** — `patch.ts` is now a recursive-descent parser over a `LineCursor` class with `indexOf`-based hunk anchoring. Hunks are stored as `{ oldBlock, newBlock }` raw strings (previously `{ oldLines[], newLines[] }` arrays), letting the applier splice content directly instead of reconstructing line arrays per apply.
   - **Two-pass diff renderer** — `diff.ts` now walks `diffLines` parts into a typed `Entry[]` stream and makes all gutter / context-collapse decisions in a second pass, replacing the prior single-loop state-flag design.
@@ -88,20 +154,17 @@ Replaced the `grep` extension with a new security-focused `sentinel` extension f
 ### Minor Changes
 
 - ### `multi-edit` — robustness improvements
-
   - **No-op write guard**: skip file write and `context-guard:file-modified` event when new content is identical to what was last read — prevents unnecessary watcher churn
   - **Early write-access check**: virtual workspace `checkWriteAccess` now validates real-filesystem permissions during the preflight pass so read-only files fail fast before any real file is touched
   - **Curly-quote normalization**: new `findActualString` helper falls back to normalized quote matching (`"` / `'` ↔ `"` / `'`) when exact `oldText` search fails — the most common class of preflight mismatch
   - **Atomic batch rollback**: `applyClassicEdits` gains a `rollbackOnError` option that restores all successfully written files when a later edit in the same batch fails
 
   ### `ask-user-question` — UX fixes
-
   - **Reliable text capture on submit**: answer is read directly from the editor before it clears itself, fixing a race where the stored value was always empty
   - **Unified advance logic**: `advanceTab()` and `saveOtherModeText()` helpers replace scattered single-question fast-paths — behaviour is now consistent regardless of form length
   - **Auto-advance on Enter / Tab**: pressing Enter or Tab in any question (text, radio with "Other", checkbox with "Other") advances to the next tab without requiring a separate click
 
   ### `team-mode` — stability fixes
-
   - **Infinite retry loop eliminated**: subprocess guard (`PI_TEAM_SUBPROCESS=1`) prevents spawned pi subprocesses from launching a ghost `LeaderRuntime` that immediately marks in-progress tasks as stalled
   - **Stall detection grace period**: tasks updated within the last 2 × `LEADER_POLL_MS` (10 s) are skipped by `detectStalledTasks` — eliminates false positives on the spawning cycle
   - **Circuit breaker**: tasks that stall more than `MAX_TASK_RETRIES` (3) times are permanently cancelled with a clear error signal instead of being silently re-queued

package/README.md

@@ -8,8 +8,9 @@ This extension adds Claude Code-style ` /btw ` behavior to pi.
 - starts a separate model request immediately
 - does not queue the question into the main agent loop
 - does not interrupt the current task
-- renders answers in a passive widget below the editor while pi keeps working
-- stores hidden history as custom session entries (`btw-history`)
+- renders active requests and answers in a focused `/btw` panel while pi keeps working
+- lets the user dismiss the panel with `Esc`/`Enter`, scroll long answers with `↑`/`↓`, and clear displayed history with `x`
+- stores hidden history as custom session entries (`btw-history`) without injecting answers into the visible transcript or main agent context
 
 ## Why it is implemented this way
 

package/index.ts

@@ -1,14 +1,14 @@
-import { complete, type UserMessage } from "@mariozechner/pi-ai";
-import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import { complete, type UserMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 
-const BTW_ENTRY_TYPE = "btw-history";
-const BTW_WIDGET_ID = "btw-widget";
+const BTW_HISTORY_ENTRY_TYPE = "btw-history";
+const LEGACY_BTW_MESSAGE_TYPE = "btw-answer";
 const COMPLETED_ITEM_TTL_MS = 90_000;
 const MAX_TRANSCRIPT_CHARS = 14_000;
 const MAX_TOOL_RESULT_CHARS = 800;
-const MAX_RENDER_ITEMS = 2;
-const MAX_RENDERED_ANSWER_LINES = 6;
+const MAX_PANEL_HISTORY_ITEMS = 5;
+const MAX_PANEL_BODY_LINES = 18;
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 
 const SIDE_QUESTION_SYSTEM_PROMPT = [
@@ -58,12 +58,14 @@ type BtwRuntime = {
 	items: BtwItem[];
 	spinnerFrame: number;
 	requestRender?: () => void;
+	closePanel?: () => void;
+	panelOpen?: boolean;
 	spinnerTimer?: ReturnType<typeof setInterval>;
 	expiryTimer?: ReturnType<typeof setTimeout>;
 };
 
 const runtimes = new Map<string, BtwRuntime>();
-const pendingPersistence = new Map<string, BtwRecord[]>();
+const pendingHistory = new Map<string, BtwRecord[]>();
 let nextItemId = 1;
 
 function getSessionKey(ctx: ExtensionContext): string {
@@ -236,42 +238,29 @@ async function askSideQuestion(question: string, ctx: ExtensionContext): Promise
 	return answer || "No response received.";
 }
 
-function ensureWidget(ctx: ExtensionContext, runtime: BtwRuntime) {
-	if (!ctx.hasUI) return;
-
-	ctx.ui.setWidget(
-		BTW_WIDGET_ID,
-		(tui, theme) => {
-			runtime.requestRender = () => tui.requestRender();
-			return new BtwWidget(theme, runtime);
-		},
-		{ placement: "belowEditor" },
-	);
-}
-
-function persistOrQueue(pi: ExtensionAPI, ctx: ExtensionContext, record: BtwRecord) {
+function persistOrQueueHistory(pi: ExtensionAPI, ctx: ExtensionContext, record: BtwRecord) {
 	if (ctx.isIdle()) {
-		pi.appendEntry(BTW_ENTRY_TYPE, record);
+		pi.appendEntry(BTW_HISTORY_ENTRY_TYPE, record);
 		return;
 	}
 
 	const key = getSessionKey(ctx);
-	const queue = pendingPersistence.get(key) ?? [];
+	const queue = pendingHistory.get(key) ?? [];
 	queue.push(record);
-	pendingPersistence.set(key, queue);
+	pendingHistory.set(key, queue);
 }
 
 function flushPendingForCurrentSession(pi: ExtensionAPI, ctx: ExtensionContext) {
 	if (!ctx.isIdle()) return;
 
 	const key = getSessionKey(ctx);
-	const queue = pendingPersistence.get(key);
+	const queue = pendingHistory.get(key);
 	if (!queue || queue.length === 0) return;
 
 	for (const record of queue) {
-		pi.appendEntry(BTW_ENTRY_TYPE, record);
+		pi.appendEntry(BTW_HISTORY_ENTRY_TYPE, record);
 	}
-	pendingPersistence.delete(key);
+	pendingHistory.delete(key);
 }
 
 function cleanupExpiredItems(runtime: BtwRuntime) {
@@ -321,7 +310,7 @@ async function startBtw(question: string, pi: ExtensionAPI, ctx: ExtensionContex
 	}
 
 	const runtime = getRuntime(ctx);
-	ensureWidget(ctx, runtime);
+	ensurePanel(ctx, runtime);
 
 	const item: BtwItem = {
 		id: `btw-${nextItemId++}`,
@@ -342,7 +331,7 @@ async function startBtw(question: string, pi: ExtensionAPI, ctx: ExtensionContex
 		item.answer = answer;
 		item.answeredAt = new Date().toISOString();
 		item.expiresAt = Date.now() + COMPLETED_ITEM_TTL_MS;
-		persistOrQueue(pi, ctx, {
+		persistOrQueueHistory(pi, ctx, {
 			question,
 			answer,
 			askedAt: item.askedAt,
@@ -355,7 +344,7 @@ async function startBtw(question: string, pi: ExtensionAPI, ctx: ExtensionContex
 		item.error = error instanceof Error ? error.message : String(error);
 		item.answeredAt = new Date().toISOString();
 		item.expiresAt = Date.now() + COMPLETED_ITEM_TTL_MS;
-		persistOrQueue(pi, ctx, {
+		persistOrQueueHistory(pi, ctx, {
 			question,
 			error: item.error,
 			askedAt: item.askedAt,
@@ -381,56 +370,123 @@ function extractBtwQuestion(text: string): string | null {
 	return match[1]?.trim() ?? "";
 }
 
-class BtwWidget {
+function indentWrapped(text: string, width: number, indent = "    "): string[] {
+	const bodyWidth = Math.max(12, width - indent.length);
+	return text.split("\n").flatMap((line) => {
+		const wrapped = wrapTextWithAnsi(line.length > 0 ? line : " ", bodyWidth);
+		return wrapped.map((part) => indent + part);
+	});
+}
+
+function ensurePanel(ctx: ExtensionContext, runtime: BtwRuntime) {
+	if (!ctx.hasUI || runtime.panelOpen) {
+		runtime.requestRender?.();
+		return;
+	}
+
+	runtime.panelOpen = true;
+	void ctx.ui
+		.custom<void>((tui, theme, _keybindings, done) => {
+			const close = () => done();
+			runtime.requestRender = () => tui.requestRender();
+			runtime.closePanel = close;
+			return new BtwPanel(theme, runtime, () => tui.requestRender(), close);
+		})
+		.finally(() => {
+			runtime.panelOpen = false;
+			runtime.closePanel = undefined;
+			runtime.requestRender = undefined;
+		});
+}
+
+class BtwPanel {
+	private scrollOffset = 0;
+
 	constructor(
 		private readonly theme: Theme,
 		private readonly runtime: BtwRuntime,
+		private readonly requestRender: () => void,
+		private readonly close: () => void,
 	) {}
 
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "enter") || matchesKey(data, "return")) {
+			this.close();
+			return;
+		}
+
+		if (data === "x" || data === "X" || matchesKey(data, "x")) {
+			this.runtime.items = this.runtime.items.filter((item) => item.state === "loading");
+			this.scrollOffset = 0;
+			syncRuntimeTimers(this.runtime);
+			if (this.runtime.items.length === 0) {
+				this.close();
+			} else {
+				this.requestRender();
+			}
+			return;
+		}
+
+		if (matchesKey(data, "up")) {
+			this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+			this.requestRender();
+			return;
+		}
+
+		if (matchesKey(data, "down")) {
+			this.scrollOffset += 1;
+			this.requestRender();
+			return;
+		}
+
+		if (matchesKey(data, "home")) {
+			this.scrollOffset = 0;
+			this.requestRender();
+		}
+	}
+
 	render(width: number): string[] {
 		cleanupExpiredItems(this.runtime);
 		if (this.runtime.items.length === 0) {
-			return [];
+			return [this.theme.fg("dim", "No /btw history."), this.theme.fg("dim", "Esc to close")].map((line) =>
+				truncateToWidth(line, width, "...", true),
+			);
 		}
 
 		const innerWidth = Math.max(24, width);
+		const latest = this.runtime.items[0]!;
 		const lines: string[] = [];
-		const activeCount = this.runtime.items.filter((item) => item.state === "loading").length;
-		const recentCount = this.runtime.items.filter((item) => item.state !== "loading").length;
-		const summaryParts = [activeCount > 0 ? `${activeCount} running` : undefined, recentCount > 0 ? `${recentCount} recent` : undefined]
-			.filter(Boolean)
-			.join(" · ");
-
-		lines.push(this.theme.fg("accent", "BTW") + (summaryParts ? this.theme.fg("dim", ` · ${summaryParts}`) : ""));
-		lines.push(this.theme.fg("borderMuted", "─".repeat(Math.max(1, innerWidth - 2))));
-
-		for (const item of this.runtime.items.slice(0, MAX_RENDER_ITEMS)) {
-			const questionLines = wrapTextWithAnsi(this.theme.fg("accent", `Q: ${item.question}`), innerWidth);
-			lines.push(...questionLines);
-
-			if (item.state === "loading") {
-				const frame = SPINNER_FRAMES[this.runtime.spinnerFrame] ?? SPINNER_FRAMES[0]!;
-				lines.push(this.theme.fg("warning", `${frame} Answering with ${item.model}...`));
-			} else {
-				const body = item.state === "error" ? this.theme.fg("error", item.error ?? "Unknown error") : item.answer ?? "";
-				const wrapped = body
-					.split("\n")
-					.flatMap((line) => wrapTextWithAnsi(line.length > 0 ? line : " ", innerWidth));
-				const clipped = wrapped.slice(0, MAX_RENDERED_ANSWER_LINES);
-				lines.push(...clipped);
-				if (wrapped.length > clipped.length) {
-					lines.push(this.theme.fg("dim", `... ${wrapped.length - clipped.length} more line(s)`));
-				}
-			}
+		lines.push(this.theme.fg("accent", "/btw"));
+		lines.push("");
+
+		for (const item of this.runtime.items.slice(0, MAX_PANEL_HISTORY_ITEMS).reverse()) {
+			const question = `/btw ${item.question}`;
+			const color = item.id === latest.id ? "accent" : "dim";
+			lines.push(...wrapTextWithAnsi(`  ${this.theme.fg(color, question)}`, innerWidth));
+		}
+
+		lines.push("");
 
-			lines.push("");
+		let bodyLines: string[];
+		if (latest.state === "loading") {
+			const frame = SPINNER_FRAMES[this.runtime.spinnerFrame] ?? SPINNER_FRAMES[0]!;
+			bodyLines = [this.theme.fg("warning", `    ${frame} Answering…`)];
+		} else if (latest.state === "error") {
+			bodyLines = indentWrapped(this.theme.fg("error", latest.error ?? "Unknown error"), innerWidth);
+		} else {
+			bodyLines = indentWrapped(latest.answer ?? "No response received.", innerWidth);
 		}
 
-		if (lines[lines.length - 1] === "") {
-			lines.pop();
+		const maxOffset = Math.max(0, bodyLines.length - MAX_PANEL_BODY_LINES);
+		this.scrollOffset = Math.min(this.scrollOffset, maxOffset);
+		lines.push(...bodyLines.slice(this.scrollOffset, this.scrollOffset + MAX_PANEL_BODY_LINES));
+
+		if (bodyLines.length > MAX_PANEL_BODY_LINES) {
+			lines.push(this.theme.fg("dim", `    ... ${bodyLines.length - this.scrollOffset - MAX_PANEL_BODY_LINES} more line(s)`));
 		}
 
-		lines.push(this.theme.fg("dim", "Use /btw <question> anytime, even while pi is still working."));
+		lines.push("");
+		lines.push(this.theme.fg("dim", "↑/↓ to scroll · x to clear history · Enter/Esc to close"));
 		return lines.map((line) => truncateToWidth(line, width, "...", true));
 	}
 
@@ -438,8 +494,13 @@ class BtwWidget {
 }
 
 export default function (pi: ExtensionAPI) {
-	const attachCurrentSessionWidget = (_event: unknown, ctx: ExtensionContext) => {
-		ensureWidget(ctx, getRuntime(ctx));
+	// Hide answers written by older versions of this extension. New answers are
+	// shown in the focused /btw panel only, so users can dismiss them with Esc.
+	pi.registerMessageRenderer(LEGACY_BTW_MESSAGE_TYPE, () => {
+		return { render: () => [], invalidate: () => {} };
+	});
+
+	const onSessionStart = (_event: unknown, ctx: ExtensionContext) => {
 		flushPendingForCurrentSession(pi, ctx);
 	};
 
@@ -447,13 +508,18 @@ export default function (pi: ExtensionAPI) {
 		flushPendingForCurrentSession(pi, ctx);
 	};
 
-	pi.on("session_start", attachCurrentSessionWidget);
-	pi.on("session_switch", attachCurrentSessionWidget);
+	pi.on("session_start", onSessionStart);
+	pi.on("context", (event) => ({
+		messages: event.messages.filter(
+			(message) => !(message.role === "custom" && (message as { customType?: string }).customType === LEGACY_BTW_MESSAGE_TYPE),
+		),
+	}));
 	pi.on("agent_end", flush);
 	pi.on("session_before_switch", flush);
 	pi.on("session_before_fork", flush);
 	pi.on("session_shutdown", (_event, _ctx) => {
 		for (const runtime of runtimes.values()) {
+			runtime.closePanel?.();
 			if (runtime.spinnerTimer) clearInterval(runtime.spinnerTimer);
 			if (runtime.expiryTimer) clearTimeout(runtime.expiryTimer);
 		}
@@ -468,6 +534,8 @@ export default function (pi: ExtensionAPI) {
 			return { action: "continue" as const };
 		}
 
+		flushPendingForCurrentSession(pi, ctx);
+
 		const question = extractBtwQuestion(event.text);
 		if (question === null) {
 			return { action: "continue" as const };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "pi-mono-btw",
-  "version": "1.7.0",
+  "version": "1.7.4",
   "description": "Pi extension that answers side questions while the main agent keeps running",
   "keywords": [
     "pi-package",
     "pi-extension"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
     "@sinclair/typebox": "*"
   },
   "pi": {