@danypops/pi-papyrus 0.58.0 → 0.59.1

package/extension/src/index.ts

@@ -42,7 +42,7 @@ import { ensureTypingCourtesyTracking, isLiveAskPending } from "./discuss/discus
 import { resolveNameFields } from "./domain-tools.ts";
 import { buildNoteWidgetSection, type NoteWidgetRow } from "./note/note-widget.ts";
 import { PLAYBOOK_BRIDGE_MAX_PLAYBOOKS, registerPlaybookBridge } from "./playbook/playbook-bridge.ts";
-import { callService, subscribeTaskPushChannel } from "./service-client.ts";
+import { callService, callServicePassive, subscribeTaskPushChannel } from "./service-client.ts";
 import { cacheSessionSecret, forgetSessionSecret, sessionSecretField } from "./session-identity.ts";
 import {
 	ActiveTaskContinuation,
@@ -154,6 +154,7 @@ export class TaskOverlay {
 	private snapshot: TaskGraph = { nodes: [], rootIds: [] };
 	private projectRoot: string | undefined;
 	private sessionId: string | undefined;
+	private generation = 0;
 	private readonly poll = new BoundedPoll();
 	private pushChannel: PushChannelClient | undefined;
 	private readonly rotation = new AutoRotatingWindow({
@@ -167,11 +168,13 @@ export class TaskOverlay {
 	}
 
 	setProjectRoot(projectRoot: string): void {
+		if (projectRoot !== this.projectRoot) this.generation++;
 		this.projectRoot = projectRoot;
 	}
 	// Scopes the widget's "active" glyph to this Pi session's own Focus, so a second
 	// concurrent agent's focused task never shows as active in this session's widget.
 	setSessionId(sessionId: string): void {
+		if (sessionId !== this.sessionId) this.generation++;
 		this.sessionId = sessionId;
 	}
 
@@ -183,15 +186,20 @@ export class TaskOverlay {
 	 */
 	async refresh(): Promise<void> {
 		if (!this.projectRoot) return;
+		const generation = this.generation;
+		const sessionId = this.sessionId;
+		let snapshot: TaskGraph;
 		try {
-			this.snapshot = await callService<Record<string, unknown>, TaskGraph>("tasks.graph", {
+			snapshot = await callServicePassive<Record<string, unknown>, TaskGraph>("tasks.graph", {
 				limit: 500,
 				project_root: this.projectRoot,
-				session_id: this.sessionId,
+				session_id: sessionId,
 			});
 		} catch {
-			this.snapshot = { nodes: [], rootIds: [] };
+			snapshot = { nodes: [], rootIds: [] };
 		}
+		if (generation !== this.generation) return;
+		this.snapshot = snapshot;
 		try {
 			this.widgetGroup?.requestUpdate();
 		} catch {
@@ -240,6 +248,7 @@ export class TaskOverlay {
 	}
 
 	dispose(): void {
+		this.generation++;
 		this.stopPolling();
 		this.pushChannel?.close();
 		this.pushChannel = undefined;
@@ -259,6 +268,7 @@ export class NoteOverlay {
 	private notes: NoteWidgetRow[] = [];
 	private totalOpenCount = 0;
 	private projectRoot: string | undefined;
+	private generation = 0;
 	private readonly poll = new BoundedPoll();
 	private readonly rotation = new AutoRotatingWindow({
 		totalRows: 0,
@@ -271,22 +281,29 @@ export class NoteOverlay {
 	}
 
 	setProjectRoot(projectRoot: string): void {
+		if (projectRoot !== this.projectRoot) this.generation++;
 		this.projectRoot = projectRoot;
 	}
 
 	async refresh(): Promise<void> {
 		if (!this.projectRoot) return;
+		const generation = this.generation;
+		const projectRoot = this.projectRoot;
+		let notes: NoteWidgetRow[] = [];
+		let totalOpenCount = 0;
 		try {
-			const rows = await callService<Record<string, unknown>, Artifact[]>("notes.list", {
-				project_root: this.projectRoot,
+			const rows = await callServicePassive<Record<string, unknown>, Artifact[]>("notes.list", {
+				project_root: projectRoot,
 				limit: NOTE_LIST_MAX_LIMIT,
 			});
-			this.totalOpenCount = rows.length;
-			this.notes = rows.slice(0, NOTE_WIDGET_OPEN_LIMIT).map((row) => ({ id: row.id, title: row.title }));
+			totalOpenCount = rows.length;
+			notes = rows.slice(0, NOTE_WIDGET_OPEN_LIMIT).map((row) => ({ id: row.id, title: row.title }));
 		} catch {
-			this.totalOpenCount = 0;
-			this.notes = [];
+			// A missing daemon is the normal passive-startup case.
 		}
+		if (generation !== this.generation) return;
+		this.totalOpenCount = totalOpenCount;
+		this.notes = notes;
 		try {
 			this.widgetGroup?.requestUpdate();
 		} catch {
@@ -315,6 +332,7 @@ export class NoteOverlay {
 	}
 
 	dispose(): void {
+		this.generation++;
 		this.stopPolling();
 		this.widgetGroup = undefined;
 		this.projectRoot = undefined;
@@ -441,7 +459,7 @@ export class PapyrusWidgetGroup {
 // Entry point
 // ---------------------------------------------------------------------------
 
-export default async function (pi: ExtensionAPI) {
+export default function (pi: ExtensionAPI) {
 	setTaskFocusEventBus(pi);
 	registerPlaybookBridge(pi);
 	let contextInjectionSequence = 0;
@@ -492,7 +510,12 @@ export default async function (pi: ExtensionAPI) {
 					session_id: sessionId,
 					...sessionSecretField(sessionId),
 				});
-				emitTaskFocusEvent({ taskId: paused.artifact.id, sessionId, status: "paused", effort: extractDeclaredEffort(paused.artifact.extra) });
+				emitTaskFocusEvent({
+					taskId: paused.artifact.id,
+					sessionId,
+					status: "paused",
+					effort: extractDeclaredEffort(paused.artifact.extra),
+				});
 				if (ctx.hasUI) ctx.ui.notify(`Papyrus task driving paused: ${decision.reason}. Human input resumes it automatically.`, "warning");
 			}
 		} catch {
@@ -717,15 +740,25 @@ export default async function (pi: ExtensionAPI) {
 
 	// ── Interactive artifact browsers ──────────────────────────────────
 
-	// Lazy imports keep TUI components out of non-interactive startup paths.
-	const [tasksModule, docsModule, notesModule, rulesModule, playbooksModule, discussModule] = await Promise.all([
-		import("./task/tasks.ts"),
-		import("./docs/docs.ts"),
-		import("./note/notes.ts"),
-		import("./rules/rules.ts"),
-		import("./playbook/playbooks.ts"),
-		import("./discuss/discuss.ts"),
-	]);
+	// Command modules are loaded on first use. Registration itself stays synchronous,
+	// so interactive-only TUI code cannot delay extension startup.
+	const loadTasks = () => import("./task/tasks.ts");
+	const loadDocs = () => import("./docs/docs.ts");
+	const loadNotes = () => import("./note/notes.ts");
+	const loadRules = () => import("./rules/rules.ts");
+	let loadedPlaybooks: Awaited<ReturnType<typeof importPlaybooks>> | undefined;
+	let playbooksPromise: ReturnType<typeof importPlaybooks> | undefined;
+	function importPlaybooks() {
+		return import("./playbook/playbooks.ts");
+	}
+	function loadPlaybooks() {
+		playbooksPromise ??= importPlaybooks().then((module) => {
+			loadedPlaybooks = module;
+			return module;
+		});
+		return playbooksPromise;
+	}
+	const loadDiscuss = () => import("./discuss/discuss.ts");
 	let overlay: TaskOverlay | undefined;
 	let noteOverlay: NoteOverlay | undefined;
 	let widgetGroup: PapyrusWidgetGroup | undefined;
@@ -735,20 +768,20 @@ export default async function (pi: ExtensionAPI) {
 		handler: async (_args, ctx) => {
 			overlay?.setProjectRoot(ctx.cwd);
 			overlay?.setSessionId(ctx.sessionManager.getSessionId());
-			await tasksModule.showTasks(ctx);
+			await (await loadTasks()).showTasks(ctx);
 			await overlay?.refresh();
 		},
 	});
 	pi.registerCommand("docs", {
 		description: "Browse and manage Papyrus documents (interactive)",
 		handler: async (_args, ctx) => {
-			await docsModule.showDocs(ctx);
+			await (await loadDocs()).showDocs(ctx);
 		},
 	});
 	pi.registerCommand("note", {
 		description: "Capture a deferred request directly in Papyrus",
 		handler: async (args, ctx) => {
-			await notesModule.captureNote(args, ctx);
+			await (await loadNotes()).captureNote(args, ctx);
 			await noteOverlay?.refresh();
 		},
 	});
@@ -756,34 +789,38 @@ export default async function (pi: ExtensionAPI) {
 		description: "Browse and triage the project Notes inbox",
 		handler: async (_args, ctx) => {
 			noteOverlay?.setProjectRoot(ctx.cwd);
-			await notesModule.showNotes(ctx);
+			await (await loadNotes()).showNotes(ctx);
 			await noteOverlay?.refresh();
 		},
 	});
 	pi.registerCommand("rules", {
 		description: "Browse, preview, and toggle Papyrus rules (interactive)",
 		handler: async (_args, ctx) => {
-			await rulesModule.showRules(ctx);
+			await (await loadRules()).showRules(ctx);
 		},
 	});
 	pi.registerCommand("playbooks", {
 		description: "Browse, edit, and invoke Papyrus playbooks -- trigger/steps guidance an agent reads and follows (interactive)",
 		handler: async (_args, ctx) => {
-			await playbooksModule.showPlaybooks(ctx);
+			await (await loadPlaybooks()).showPlaybooks(ctx);
 		},
 	});
 	pi.registerCommand("playbook", {
 		description:
 			"Open one Papyrus playbook directly by name (tab-completes active playbook titles) and place its invocation in the editor; no argument opens the full /playbooks browser instead",
-		getArgumentCompletions: (argumentPrefix) => playbooksModule.playbookArgumentCompletions(argumentPrefix),
+		getArgumentCompletions: (argumentPrefix) => {
+			if (loadedPlaybooks) return loadedPlaybooks.playbookArgumentCompletions(argumentPrefix);
+			void loadPlaybooks();
+			return [];
+		},
 		handler: async (args, ctx) => {
-			await playbooksModule.openPlaybookByName(args, ctx);
+			await (await loadPlaybooks()).openPlaybookByName(args, ctx);
 		},
 	});
 	pi.registerCommand("discuss", {
 		description: "Browse Papyrus Discussions and reply, defer, resume, settle, or block/unblock a task (interactive)",
 		handler: async (_args, ctx) => {
-			await discussModule.showDiscussions(ctx);
+			await (await loadDiscuss()).showDiscussions(ctx);
 		},
 	});
 
@@ -797,22 +834,19 @@ export default async function (pi: ExtensionAPI) {
 
 	// ── Task widget (TodoOverlay pattern: factory form, requestRender) ──
 
-	pi.on("session_start", async (_event, ctx) => {
-		// Registers this session's identity with the daemon as early as possible -- before any
-		// Focus-mutating call could plausibly happen -- shrinking (not eliminating; see
-		// domain/session-identity.ts) the first-touch race window. Best-effort: the daemon may be
-		// unavailable during startup, and every other Focus-mutating call already tolerates an
-		// unregistered/never-armored session_id (opt-in armor), so a missed registration here is
-		// not worth surfacing to the user.
-		try {
-			const sessionId = ctx.sessionManager.getSessionId();
-			const { secret } = await callService<Record<string, unknown>, { sessionId: string; secret: string }>("session.register", {
-				session_id: sessionId,
-			});
-			cacheSessionSecret(sessionId, secret);
-		} catch {
-			// intentionally silent -- see comment above
-		}
+	let sessionGeneration = 0;
+	pi.on("session_start", (_event, ctx) => {
+		const generation = ++sessionGeneration;
+		const sessionId = ctx.sessionManager.getSessionId();
+		// Identity registration is best-effort lifecycle bookkeeping. It starts now but
+		// cannot hold Pi's first paint behind a daemon connection or retry budget.
+		void callServicePassive<Record<string, unknown>, { sessionId: string; secret: string }>("session.register", {
+			session_id: sessionId,
+		})
+			.then(({ secret }) => {
+				if (generation === sessionGeneration) cacheSessionSecret(sessionId, secret);
+			})
+			.catch(() => {});
 		if (!ctx.hasUI) return;
 		// Attached from session start, not lazily on first ask -- a per-ask listener would only see
 		// keystrokes from the moment that tool call happens to begin, missing typing already in
@@ -824,7 +858,7 @@ export default async function (pi: ExtensionAPI) {
 		overlay ??= new TaskOverlay();
 		overlay.setWidgetGroup(widgetGroup);
 		overlay.setProjectRoot(ctx.cwd);
-		overlay.setSessionId(ctx.sessionManager.getSessionId());
+		overlay.setSessionId(sessionId);
 
 		noteOverlay ??= new NoteOverlay();
 		noteOverlay.setWidgetGroup(widgetGroup);
@@ -832,10 +866,11 @@ export default async function (pi: ExtensionAPI) {
 
 		widgetGroup.setOverlays(overlay, noteOverlay);
 
-		await overlay.refresh();
-		overlay.startPolling(TASK_WIDGET_POLL_INTERVAL_MS);
-		await noteOverlay.refresh();
-		noteOverlay.startPolling(NOTE_WIDGET_POLL_INTERVAL_MS);
+		void Promise.all([overlay.refresh(), noteOverlay.refresh()]).then(() => {
+			if (generation !== sessionGeneration) return;
+			overlay?.startPolling(TASK_WIDGET_POLL_INTERVAL_MS);
+			noteOverlay?.startPolling(NOTE_WIDGET_POLL_INTERVAL_MS);
+		});
 	});
 
 	pi.on("session_before_compact", () => {
@@ -847,20 +882,18 @@ export default async function (pi: ExtensionAPI) {
 	pi.on("session_tree", async () => {
 		await Promise.all([overlay?.refresh(), noteOverlay?.refresh()]);
 	});
-	pi.on("session_shutdown", async (_event, ctx) => {
+	pi.on("session_shutdown", (_event, ctx) => {
+		sessionGeneration++;
 		overlay?.dispose();
 		overlay = undefined;
 		noteOverlay?.dispose();
 		noteOverlay = undefined;
 		widgetGroup?.dispose();
 		widgetGroup = undefined;
-		try {
-			const sessionId = ctx.sessionManager.getSessionId();
-			await callService("session.release", { session_id: sessionId, ...sessionSecretField(sessionId) });
-			forgetSessionSecret(sessionId);
-		} catch {
-			// intentionally silent -- see session_start's comment above
-		}
+		const sessionId = ctx.sessionManager.getSessionId();
+		const secret = sessionSecretField(sessionId);
+		forgetSessionSecret(sessionId);
+		void callServicePassive("session.release", { session_id: sessionId, ...secret }).catch(() => {});
 	});
 
 	// Update widgets after any papyrus tool call

package/extension/src/playbook/playbook-bridge.ts

@@ -21,7 +21,7 @@
 import type { Artifact } from "@danypops/papyrus";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildActivationContext } from "../context/activation-context.ts";
-import { callService } from "../service-client.ts";
+import { callService, callServicePassive } from "../service-client.ts";
 
 export const PLAYBOOK_BRIDGE_MAX_PLAYBOOKS = 100;
 
@@ -34,8 +34,14 @@ function slugify(title: string): string {
 	return slug.length > 0 ? slug : "playbook";
 }
 
-async function activePlaybooks(projectRoot?: string, capabilities: readonly string[] = []): Promise<Artifact[]> {
-	return callService<Record<string, unknown>, Artifact[]>("playbooks.list", {
+type ServiceCall = <Input extends Record<string, unknown>, Output>(operation: "playbooks.list", input: Input) => Promise<Output>;
+
+async function activePlaybooks(
+	projectRoot?: string,
+	capabilities: readonly string[] = [],
+	serviceCall: ServiceCall = callService,
+): Promise<Artifact[]> {
+	return serviceCall<Record<string, unknown>, Artifact[]>("playbooks.list", {
 		status: "active",
 		full: true,
 		limit: PLAYBOOK_BRIDGE_MAX_PLAYBOOKS,
@@ -70,8 +76,9 @@ export function playbookInjectionPreview(playbook: Pick<Artifact, "title" | "ext
 export async function planPlaybookCommandRegistrations(
 	projectRoot?: string,
 	capabilities: readonly string[] = [],
+	serviceCall: ServiceCall = callService,
 ): Promise<Array<{ name: string; id: string; title: string; trigger: string }>> {
-	const playbooks = await activePlaybooks(projectRoot, capabilities);
+	const playbooks = await activePlaybooks(projectRoot, capabilities, serviceCall);
 	const usedNames = new Set<string>();
 	return playbooks.map((playbook) => {
 		let name = playbookCommandName(playbook.title);
@@ -82,10 +89,18 @@ export async function planPlaybookCommandRegistrations(
 	});
 }
 
-export function registerPlaybookBridge(pi: ExtensionAPI): void {
-	const refresh = async (projectRoot?: string) => {
+export interface PlaybookBridgeHandle {
+	/** Explicit test/shutdown boundary for the most recently scheduled discovery refresh. */
+	waitForRefresh(): Promise<void>;
+}
+
+export function registerPlaybookBridge(pi: ExtensionAPI): PlaybookBridgeHandle {
+	let generation = 0;
+	let latestRefresh = Promise.resolve();
+	const refresh = async (projectRoot: string | undefined, scheduledGeneration: number) => {
 		try {
-			const registrations = await planPlaybookCommandRegistrations(projectRoot, pi.getActiveTools?.() ?? []);
+			const registrations = await planPlaybookCommandRegistrations(projectRoot, pi.getActiveTools?.() ?? [], callServicePassive);
+			if (scheduledGeneration !== generation) return;
 			for (const { name, id, title, trigger } of registrations) {
 				pi.registerCommand(name, {
 					description: trigger,
@@ -126,8 +141,13 @@ export function registerPlaybookBridge(pi: ExtensionAPI): void {
 			// "no new/updated playbook commands this cycle", not a broken session start.
 		}
 	};
-	pi.on("resources_discover", async (event) => {
-		await refresh(event?.cwd);
+	pi.on("resources_discover", (event) => {
+		const scheduledGeneration = ++generation;
+		latestRefresh = refresh(event?.cwd, scheduledGeneration);
 		return {};
 	});
+	pi.on("session_shutdown", () => {
+		generation++;
+	});
+	return { waitForRefresh: () => latestRefresh };
 }

package/extension/src/service-client.ts

@@ -25,6 +25,13 @@ const client: RetryingClient<PapyrusClient> = createRetryingClient<PapyrusClient
 	connectRetry: true,
 });
 
+// Passive lifecycle work must fail fast when the daemon is absent. The regular
+// client keeps its restart-surviving retry budget for explicit user/tool calls.
+const passiveClient: RetryingClient<PapyrusClient> = createRetryingClient<PapyrusClient>(() => connector(), {
+	label: "Papyrus passive",
+	connectRetry: false,
+});
+
 export async function papyrusClient(): Promise<PapyrusClient> {
 	return client.call(async (resolved) => resolved);
 }
@@ -33,14 +40,24 @@ export async function callService<Input extends Record<string, unknown>, Output>
 	return client.call((resolved) => resolved.call<Input, Output>(operation, input));
 }
 
+/** Fail-fast daemon call for widgets, discovery, and lifecycle bookkeeping. */
+export async function callServicePassive<Input extends Record<string, unknown>, Output>(
+	operation: OperationName,
+	input: Input,
+): Promise<Output> {
+	return passiveClient.call((resolved) => resolved.call<Input, Output>(operation, input));
+}
+
 export function setPapyrusClientConnectorForTests(value: ClientConnector): void {
 	connector = value;
 	client.reset();
+	passiveClient.reset();
 }
 
 export function resetPapyrusClientForTests(): void {
 	connector = () => connectPapyrusClient();
 	client.reset();
+	passiveClient.reset();
 }
 
 let pushChannelTargetResolver: typeof resolvePushChannelTarget = resolvePushChannelTarget;

package/extension/src/tools/vehicle-notes-client.ts

@@ -23,6 +23,7 @@
  * had died.
  */
 
+import { createAgentNotifier } from "@danypops/vehicle-client-pi/agent-poll-ticker";
 import { createReconnectingVehicleClient, daemonInstanceIdentity } from "@danypops/vehicle-client/daemon-client";
 import { RemoteVehicleClient } from "@danypops/vehicle-client/http";
 import {
@@ -31,6 +32,7 @@ import {
 	registerVehicleToolsWhenReady,
 	type VehicleReadyEvent,
 } from "@danypops/vehicle-client-pi";
+import { VehicleApprovalOutcomePoll } from "@danypops/vehicle-client-pi/vehicle-approval-outcome-poll";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { discussLiveFollowUp } from "../discuss/discuss-live-follow-up.ts";
 import { currentVehicleClientTarget } from "../service-client.ts";
@@ -61,6 +63,13 @@ export const PAPYRUS_VEHICLE_PERMISSIONS = [
 /** Task Focus's own internal write needs a real, per-session secret -- see below. Every other tasks.* operation reads session_id purely for read-scoping and needs no secret. */
 const FOCUS_MUTATION_OPERATIONS = new Set(["tasks.focus", "tasks.pause", "tasks.unpause", "tasks.clear_focus"]);
 
+/** Matches pi-tickets' own watch-events poll cadence -- no established Papyrus-specific reason
+ * to differ, and this Vehicle doesn't call configureApprovals() on anything today, so nothing yet
+ * actually exercises this path; it exists so a future gated operation (e.g. a genuinely
+ * destructive artifact mutation) gets outcome-visibility for free rather than needing this same
+ * wiring added later. */
+const APPROVAL_OUTCOME_POLL_INTERVAL_MS = 30_000;
+
 /**
  * Vehicle Shell's core set (see @danypops/vehicle-client-pi's registerVehicleTools `shell`
  * option): the handful of operations used in nearly every session, active from turn one with no
@@ -134,6 +143,22 @@ export function registerNotesVehicle(pi: ExtensionAPI): Promise<RegisteredPiVehi
 			connectRetry: true,
 		},
 	);
+	// Push half of the Approval Gate's outcome-visibility story -- see
+	// @danypops/vehicle-client-pi's own vehicle-approval-outcome-poll.ts doc comment (the Papyrus
+	// Discussion parallel this mirrors) and pi-tickets' identical wiring in vehicle-client.ts.
+	const approvalOutcomePoll = new VehicleApprovalOutcomePoll(client, createAgentNotifier(pi));
+	let approvalOutcomePollTimer: ReturnType<typeof setInterval> | undefined;
+	pi.on("session_start", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+		if (approvalOutcomePollTimer) return;
+		approvalOutcomePollTimer = setInterval(() => void approvalOutcomePoll.poll(), APPROVAL_OUTCOME_POLL_INTERVAL_MS);
+		void approvalOutcomePoll.poll(); // an outcome may already be resolved before this session ever started polling
+	});
+	pi.on("session_shutdown", () => {
+		if (!approvalOutcomePollTimer) return;
+		clearInterval(approvalOutcomePollTimer);
+		approvalOutcomePollTimer = undefined;
+	});
 	return registerVehicleToolsWhenReady(pi, () => Promise.resolve(currentVehicleClientTarget() ? client : undefined), {
 		// registerVehicleMetricsOperations(..., "papyrus") in @danypops/papyrus's own daemon.ts uses
 		// the default "metrics" prefix -- without this, its metrics.query/metrics.recordClientEvent
@@ -205,6 +230,7 @@ export function registerNotesVehicle(pi: ExtensionAPI): Promise<RegisteredPiVehi
 		// couldn't batch a live ask alongside other tool calls in the same turn and
 		// let those run before the human sees the prompt -- same reasoning here.
 		executionMode: (descriptor) => (descriptor.name === "discuss.open" || descriptor.name === "discuss.reply" ? "sequential" : undefined),
+		onApprovalPending: (requestId, descriptor) => approvalOutcomePoll.record(requestId, descriptor.name),
 		onInvoked: ({ descriptor }, output) => {
 			// See vehicle-notes-client.ts's log wiring above -- correlates a real invocation's
 			// timestamp against when registration actually completed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/pi-papyrus",
-  "version": "0.58.0",
+  "version": "0.59.1",
   "description": "Pi host extension for Papyrus: native tools, TUI panels, and context injection over the daemon-backed graph store",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,7 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@danypops/vehicle-client-pi": "^0.45.1",
+    "@danypops/vehicle-client-pi": "^0.46.0",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
@@ -28,8 +28,9 @@
     "malevich-tui-components": "^0.32.1"
   },
   "devDependencies": {
+    "@danypops/pi-extension-harness": "^0.8.3",
     "@danypops/pi-tui-harness": "^0.0.2",
-    "@danypops/vehicle-client-pi": "^0.45.1",
+    "@danypops/vehicle-client-pi": "^0.46.0",
     "@danypops/vehicle-conformance": "^0.3.0",
     "@earendil-works/pi-coding-agent": "^0.80.10",
     "bun-types": "latest",