gsd-pi 2.76.0 → 2.77.0

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.76.0",
+  "version": "2.77.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

package/packages/pi-coding-agent/src/core/agent-session-abort-order.test.ts

@@ -14,8 +14,9 @@ describe("#4243 — abort() must be called before _disconnectFromAgent()", () =>
 		const newSessionStart = source.indexOf("async newSession(options?:");
 		assert.ok(newSessionStart >= 0, "should find newSession method");
 
-		// Get a window that includes the abort/disconnect section
-		const window = source.slice(newSessionStart, newSessionStart + 1200);
+		// Get a window that includes the abort/disconnect section.
+		// Use 2000 chars to accommodate guard checks inserted between the two calls.
+		const window = source.slice(newSessionStart, newSessionStart + 2000);
 
 		// Find the abort and _disconnectFromAgent calls
 		const abortIdx = window.indexOf("await this.abort();");

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -621,6 +621,19 @@ export class AgentSession {
 			await this._extensionRunner.emit({ type: "agent_start" });
 		} else if (event.type === "agent_end") {
 			await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
+			// `stop` fires on true quiescence: the agent cleanly completed and is now
+			// waiting for the user. Use the last assistant message's stopReason to
+			// distinguish clean completion from error/cancellation.
+			const last = event.messages[event.messages.length - 1];
+			const stopReason: "completed" | "cancelled" | "error" | "blocked" =
+				last?.role === "assistant"
+					? last.stopReason === "aborted"
+						? "cancelled"
+						: last.stopReason === "error"
+							? "error"
+							: "completed"
+					: "completed";
+			await this._extensionRunner.emitStop({ reason: stopReason, lastMessage: last });
 		} else if (event.type === "turn_start") {
 			const extensionEvent: TurnStartEvent = {
 				type: "turn_start",
@@ -1523,12 +1536,24 @@ export class AgentSession {
 		await this.agent.waitForIdle();
 		// Ensure agent_end is emitted even when abort interrupts a tool call (#1414).
 		// The agent may go idle without emitting agent_end if the abort happens
-		// between tool execution and response processing.
+		// between tool execution and response processing. Also fire Stop so
+		// Layer 0 hooks see a consistent view of session quiescence.
 		if (!this.isStreaming && this._extensionRunner) {
+			const messages = this.agent.state.messages;
 			await this._extensionRunner.emit({
 				type: "agent_end",
-				messages: this.agent.state.messages,
+				messages,
 			});
+			const last = messages[messages.length - 1];
+			const stopReason: "completed" | "cancelled" | "error" | "blocked" =
+				last?.role === "assistant"
+					? last.stopReason === "aborted"
+						? "cancelled"
+						: last.stopReason === "error"
+							? "error"
+							: "completed"
+					: "cancelled";
+			await this._extensionRunner.emitStop({ reason: stopReason, lastMessage: last });
 		}
 	}
 
@@ -1543,6 +1568,8 @@ export class AgentSession {
 	async newSession(options?: {
 		parentSession?: string;
 		setup?: (sessionManager: SessionManager) => Promise<void>;
+		/** See ExtensionCommandContext.newSession for docs (#3731). */
+		abortSignal?: AbortSignal;
 	}): Promise<boolean> {
 		const previousSessionFile = this.sessionFile;
 
@@ -1562,6 +1589,15 @@ export class AgentSession {
 	// message_end/agent_end events fire and the #4216 finalization code
 	// can run before we unsubscribe from the event bus.
 	await this.abort();
+
+		// #3731: If the caller aborted (e.g. runUnit() timed out and restored cwd to
+		// project root), discard this session before capturing process.cwd() and
+		// rebuilding the tool runtime. Without this check, the late newSession()
+		// would rebuild tools with root cwd, breaking worktree isolation.
+		if (options?.abortSignal?.aborted) {
+			return false;
+		}
+
 	this._disconnectFromAgent();
 	this.agent.reset();
 		// Update cwd to current process directory — auto-mode may have chdir'd

package/packages/pi-coding-agent/src/core/extensions/index.ts

@@ -39,8 +39,24 @@ export type {
 	BashToolResultEvent,
 	BeforeAgentStartEvent,
 	BeforeAgentStartEventResult,
+	BeforeCommitEvent,
+	BeforeCommitEventResult,
+	BeforePrEvent,
+	BeforePrEventResult,
+	BeforePushEvent,
+	BeforePushEventResult,
+	BeforeVerifyEvent,
+	BeforeVerifyEventResult,
+	BudgetThresholdEvent,
+	BudgetThresholdEventResult,
 	BeforeProviderRequestEvent,
 	BeforeProviderRequestEventResult,
+	CommitEvent,
+	NotificationEvent,
+	PrOpenedEvent,
+	PushEvent,
+	VerifyFailure,
+	VerifyResultEvent,
 	// Context
 	CompactOptions,
 	// Events - Adjust Tool Set (ADR-005)

package/packages/pi-coding-agent/src/core/extensions/loader.ts

@@ -432,6 +432,7 @@ export function createExtensionRuntime(): ExtensionRuntime {
 		// Stubs replaced by ExtensionRunner at construction time via bindEmitMethods().
 		emitBeforeModelSelect: async () => undefined,
 		emitAdjustToolSet: async () => undefined,
+		emitExtensionEvent: async () => undefined,
 	};
 
 	return runtime;
@@ -595,6 +596,10 @@ function createExtensionAPI(
 			return runtime.emitAdjustToolSet(event);
 		},
 
+		async emitExtensionEvent(event: import("./types.js").ExtensionEvent): Promise<unknown> {
+			return runtime.emitExtensionEvent(event);
+		},
+
 		events: eventBus,
 	} as ExtensionAPI;
 

package/packages/pi-coding-agent/src/core/extensions/runner.ts

@@ -15,9 +15,20 @@ import type {
 	AdjustToolSetResult,
 	BeforeAgentStartEvent,
 	BeforeAgentStartEventResult,
+	BeforeCommitEvent,
+	BeforeCommitEventResult,
 	BeforeModelSelectEvent,
 	BeforeModelSelectResult,
+	BeforePrEvent,
+	BeforePrEventResult,
 	BeforeProviderRequestEvent,
+	BeforePushEvent,
+	BeforePushEventResult,
+	BeforeVerifyEvent,
+	BeforeVerifyEventResult,
+	BudgetThresholdEvent,
+	BudgetThresholdEventResult,
+	CommitEvent,
 	CompactOptions,
 	ContextEvent,
 	ContextEventResult,
@@ -38,6 +49,11 @@ import type {
 	InputEventResult,
 	InputSource,
 	MessageRenderer,
+	MilestoneEndEvent,
+	MilestoneStartEvent,
+	NotificationEvent,
+	PrOpenedEvent,
+	PushEvent,
 	RegisteredCommand,
 	RegisteredTool,
 	ResourcesDiscoverEvent,
@@ -46,12 +62,18 @@ import type {
 	SessionBeforeForkResult,
 	SessionBeforeSwitchResult,
 	SessionBeforeTreeResult,
+	SessionEndEvent,
+	StopEvent,
 	ToolCallEvent,
 	ToolCallEventResult,
 	ToolResultEvent,
 	ToolResultEventResult,
+	UnitEndEvent,
+	UnitStartEvent,
 	UserBashEvent,
 	UserBashEventResult,
+	VerifyFailure,
+	VerifyResultEvent,
 } from "./types.js";
 
 // Keybindings for these actions cannot be overridden by extensions
@@ -142,6 +164,8 @@ export type ExtensionErrorListener = (error: ExtensionError) => void;
 export type NewSessionHandler = (options?: {
 	parentSession?: string;
 	setup?: (sessionManager: SessionManager) => Promise<void>;
+	/** See ExtensionCommandContext.newSession for docs (#3731). */
+	abortSignal?: AbortSignal;
 }) => Promise<{ cancelled: boolean }>;
 
 export type ForkHandler = (entryId: string) => Promise<{ cancelled: boolean }>;
@@ -237,6 +261,127 @@ export class ExtensionRunner {
 		// Bind emit methods into the shared runtime so createExtensionAPI can delegate to them.
 		this.runtime.emitBeforeModelSelect = (event) => this.emitBeforeModelSelect(event);
 		this.runtime.emitAdjustToolSet = (event) => this.emitAdjustToolSet(event);
+		this.runtime.emitExtensionEvent = (event) => this.emitExtensionEventDynamic(event);
+	}
+
+	/**
+	 * Dispatch an ExtensionEvent by type. Used by extensions to emit the
+	 * post-plan Layer 2 events (git lifecycle, verify, budget, milestone,
+	 * unit, notification, stop, session_end) without a bespoke method per
+	 * type. Returns the handler chain's aggregate result where meaningful.
+	 */
+	private async emitExtensionEventDynamic(event: ExtensionEvent): Promise<unknown> {
+		switch (event.type) {
+			case "notification":
+				return this.emitNotification({ kind: event.kind, message: event.message, details: event.details });
+			case "stop":
+				return this.emitStop({ reason: event.reason, lastMessage: event.lastMessage });
+			case "session_end":
+				return this.emitSessionEnd({ reason: event.reason, sessionFile: event.sessionFile });
+			case "before_commit":
+				return this.emitBeforeCommit({
+					message: event.message,
+					files: event.files,
+					cwd: event.cwd,
+					author: event.author,
+				});
+			case "commit":
+				return this.emitCommit({ sha: event.sha, message: event.message, files: event.files, cwd: event.cwd });
+			case "before_push":
+				return this.emitBeforePush({ remote: event.remote, branch: event.branch, cwd: event.cwd });
+			case "push":
+				return this.emitPush({ remote: event.remote, branch: event.branch, cwd: event.cwd });
+			case "before_pr":
+				return this.emitBeforePr({
+					branch: event.branch,
+					targetBranch: event.targetBranch,
+					title: event.title,
+					body: event.body,
+					cwd: event.cwd,
+				});
+			case "pr_opened":
+				return this.emitPrOpened({
+					url: event.url,
+					branch: event.branch,
+					targetBranch: event.targetBranch,
+					cwd: event.cwd,
+				});
+			case "before_verify":
+				return this.emitBeforeVerify({ unitType: event.unitType, unitId: event.unitId, cwd: event.cwd });
+			case "verify_result":
+				return this.emitVerifyResult({
+					passed: event.passed,
+					failures: event.failures,
+					unitType: event.unitType,
+					unitId: event.unitId,
+					cwd: event.cwd,
+				});
+			case "budget_threshold":
+				return this.emitBudgetThreshold({
+					fraction: event.fraction,
+					spent: event.spent,
+					limit: event.limit,
+					currency: event.currency,
+				});
+			case "milestone_start":
+				return this.emitMilestoneStart({ milestoneId: event.milestoneId, title: event.title, cwd: event.cwd });
+			case "milestone_end":
+				return this.emitMilestoneEnd({
+					milestoneId: event.milestoneId,
+					status: event.status,
+					cwd: event.cwd,
+				});
+			case "unit_start":
+				return this.emitUnitStart({
+					unitType: event.unitType,
+					unitId: event.unitId,
+					milestoneId: event.milestoneId,
+					cwd: event.cwd,
+				});
+			case "unit_end":
+				return this.emitUnitEnd({
+					unitType: event.unitType,
+					unitId: event.unitId,
+					milestoneId: event.milestoneId,
+					status: event.status,
+					cwd: event.cwd,
+				});
+			default:
+				return undefined;
+		}
+	}
+
+	/**
+	 * Install a synthetic "extension" that only provides event handlers.
+	 * Used by the Layer 0 hooks-runner to bridge shell hooks onto the
+	 * extension event bus without requiring a full extension module. The
+	 * returned disposer removes the synthetic extension.
+	 */
+	installHookBridge(
+		path: string,
+		handlers: Map<string, Array<(event: unknown, ctx: unknown) => Promise<unknown>>>,
+	): () => void {
+		const synthetic: Extension = {
+			path,
+			resolvedPath: path,
+			handlers: handlers as unknown as Extension["handlers"],
+			tools: new Map(),
+			messageRenderers: new Map(),
+			commands: new Map(),
+			flags: new Map(),
+			shortcuts: new Map(),
+			lifecycleHooks: {
+				beforeInstall: [],
+				afterInstall: [],
+				beforeRemove: [],
+				afterRemove: [],
+			},
+		};
+		this.extensions.push(synthetic);
+		return () => {
+			const index = this.extensions.indexOf(synthetic);
+			if (index >= 0) this.extensions.splice(index, 1);
+		};
 	}
 
 	bindCore(actions: ExtensionActions, contextActions: ExtensionContextActions): void {
@@ -825,4 +970,210 @@ export class ExtensionRunner {
 			? { action: "transform", text: currentText, images: currentImages }
 			: { action: "continue" };
 	}
+
+	// =========================================================================
+	// Layer 2 event emitters (notification, stop, session_end, git, verify,
+	// budget, milestone / unit). Fire-and-observe except where a handler result
+	// can veto or rewrite the pending action.
+	// =========================================================================
+
+	async emitStop(event: Omit<StopEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"stop",
+			() => ({ type: "stop" as const, ...event } satisfies StopEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitNotification(event: Omit<NotificationEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"notification",
+			() => ({ type: "notification" as const, ...event } satisfies NotificationEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitSessionEnd(event: Omit<SessionEndEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"session_end",
+			() => ({ type: "session_end" as const, ...event } satisfies SessionEndEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitBeforeCommit(
+		event: Omit<BeforeCommitEvent, "type">,
+	): Promise<BeforeCommitEventResult | undefined> {
+		let result: BeforeCommitEventResult | undefined;
+		let message = event.message;
+		await this.invokeHandlers(
+			"before_commit",
+			() => ({ type: "before_commit" as const, ...event, message } satisfies BeforeCommitEvent),
+			(handlerResult) => {
+				const r = handlerResult as BeforeCommitEventResult | undefined;
+				if (!r) return { done: false };
+				if (r.cancel) {
+					result = { cancel: true, reason: r.reason };
+					return { done: true };
+				}
+				if (r.message !== undefined) {
+					message = r.message;
+					result = { ...(result ?? {}), message };
+				}
+				return { done: false };
+			},
+		);
+		return result;
+	}
+
+	async emitCommit(event: Omit<CommitEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"commit",
+			() => ({ type: "commit" as const, ...event } satisfies CommitEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitBeforePush(
+		event: Omit<BeforePushEvent, "type">,
+	): Promise<BeforePushEventResult | undefined> {
+		let result: BeforePushEventResult | undefined;
+		await this.invokeHandlers(
+			"before_push",
+			() => ({ type: "before_push" as const, ...event } satisfies BeforePushEvent),
+			(handlerResult) => {
+				const r = handlerResult as BeforePushEventResult | undefined;
+				if (r?.cancel) {
+					result = r;
+					return { done: true };
+				}
+				return { done: false };
+			},
+		);
+		return result;
+	}
+
+	async emitPush(event: Omit<PushEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"push",
+			() => ({ type: "push" as const, ...event } satisfies PushEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitBeforePr(
+		event: Omit<BeforePrEvent, "type">,
+	): Promise<BeforePrEventResult | undefined> {
+		let result: BeforePrEventResult | undefined;
+		let title = event.title;
+		let body = event.body;
+		await this.invokeHandlers(
+			"before_pr",
+			() => ({ type: "before_pr" as const, ...event, title, body } satisfies BeforePrEvent),
+			(handlerResult) => {
+				const r = handlerResult as BeforePrEventResult | undefined;
+				if (!r) return { done: false };
+				if (r.cancel) {
+					result = { cancel: true, reason: r.reason };
+					return { done: true };
+				}
+				if (r.title !== undefined) title = r.title;
+				if (r.body !== undefined) body = r.body;
+				if (r.title !== undefined || r.body !== undefined) {
+					result = { ...(result ?? {}), title, body };
+				}
+				return { done: false };
+			},
+		);
+		return result;
+	}
+
+	async emitPrOpened(event: Omit<PrOpenedEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"pr_opened",
+			() => ({ type: "pr_opened" as const, ...event } satisfies PrOpenedEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitBeforeVerify(
+		event: Omit<BeforeVerifyEvent, "type">,
+	): Promise<BeforeVerifyEventResult | undefined> {
+		let result: BeforeVerifyEventResult | undefined;
+		await this.invokeHandlers(
+			"before_verify",
+			() => ({ type: "before_verify" as const, ...event } satisfies BeforeVerifyEvent),
+			(handlerResult) => {
+				const r = handlerResult as BeforeVerifyEventResult | undefined;
+				if (r?.cancel) {
+					result = r;
+					return { done: true };
+				}
+				return { done: false };
+			},
+		);
+		return result;
+	}
+
+	async emitVerifyResult(event: Omit<VerifyResultEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"verify_result",
+			() => ({ type: "verify_result" as const, ...event } satisfies VerifyResultEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitBudgetThreshold(
+		event: Omit<BudgetThresholdEvent, "type">,
+	): Promise<BudgetThresholdEventResult | undefined> {
+		let result: BudgetThresholdEventResult | undefined;
+		await this.invokeHandlers(
+			"budget_threshold",
+			() => ({ type: "budget_threshold" as const, ...event } satisfies BudgetThresholdEvent),
+			(handlerResult) => {
+				const r = handlerResult as BudgetThresholdEventResult | undefined;
+				if (r?.action) {
+					result = r;
+					return { done: true };
+				}
+				return { done: false };
+			},
+		);
+		return result;
+	}
+
+	async emitMilestoneStart(event: Omit<MilestoneStartEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"milestone_start",
+			() => ({ type: "milestone_start" as const, ...event } satisfies MilestoneStartEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitMilestoneEnd(event: Omit<MilestoneEndEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"milestone_end",
+			() => ({ type: "milestone_end" as const, ...event } satisfies MilestoneEndEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitUnitStart(event: Omit<UnitStartEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"unit_start",
+			() => ({ type: "unit_start" as const, ...event } satisfies UnitStartEvent),
+			() => ({ done: false }),
+		);
+	}
+
+	async emitUnitEnd(event: Omit<UnitEndEvent, "type">): Promise<void> {
+		await this.invokeHandlers(
+			"unit_end",
+			() => ({ type: "unit_end" as const, ...event } satisfies UnitEndEvent),
+			() => ({ done: false }),
+		);
+	}
 }
+
+/** Helper re-export for callers wiring verification failures. */
+export type { VerifyFailure };