gsd-pi 2.75.0-next.9c0ec0ba1 → 2.76.0-dev.b072ebb73

package/packages/pi-coding-agent/src/core/auth-storage.test.ts

@@ -610,3 +610,45 @@ describe("AuthStorage — hasLegacyOAuthCredential (#4280)", () => {
 		assert.equal(storage.hasLegacyOAuthCredential("github-copilot"), true);
 	});
 });
+
+// ─── removeLegacyOAuthCredential (self-heal for #3952 / #4368) ───────────────
+
+describe("AuthStorage — removeLegacyOAuthCredential (#4368)", () => {
+	it("removes oauth entry and returns true when present", () => {
+		const storage = inMemory({
+			anthropic: {
+				type: "oauth",
+				access: "fake",
+				refresh: "fake",
+				expires: Date.now() + 3_600_000,
+			},
+		});
+		assert.equal(storage.removeLegacyOAuthCredential("anthropic"), true);
+		assert.equal(storage.hasLegacyOAuthCredential("anthropic"), false);
+		assert.equal(storage.has("anthropic"), false);
+	});
+
+	it("returns false when no oauth entry exists", () => {
+		const storage = inMemory({ anthropic: makeKey("sk-ant-fake") });
+		assert.equal(storage.removeLegacyOAuthCredential("anthropic"), false);
+		assert.equal(storage.get("anthropic")?.type, "api_key");
+	});
+
+	it("preserves api_key credentials alongside oauth entry", () => {
+		const storage = inMemory({
+			anthropic: [
+				makeKey("sk-ant-keep"),
+				{
+					type: "oauth",
+					access: "fake",
+					refresh: "fake",
+					expires: Date.now() + 3_600_000,
+				},
+			],
+		});
+		assert.equal(storage.removeLegacyOAuthCredential("anthropic"), true);
+		const remaining = storage.getCredentialsForProvider("anthropic");
+		assert.equal(remaining.length, 1);
+		assert.equal(remaining[0].type, "api_key");
+	});
+});

package/packages/pi-coding-agent/src/core/auth-storage.ts

@@ -475,6 +475,31 @@ export class AuthStorage {
 		return this.getCredentialsForProvider(provider).some((c) => c.type === "oauth");
 	}
 
+	/**
+	 * Remove only oauth-type credentials for a provider, preserving any api_key
+	 * entries. Used to self-heal stale OAuth credentials for providers where
+	 * OAuth support has been removed (e.g. Anthropic, #3952) without destroying
+	 * a user's valid API keys. Returns true if any oauth entries were removed.
+	 */
+	removeLegacyOAuthCredential(provider: string): boolean {
+		const existing = this.getCredentialsForProvider(provider);
+		const remaining = existing.filter((c) => c.type !== "oauth");
+		if (remaining.length === existing.length) return false;
+
+		if (remaining.length === 0) {
+			delete this.data[provider];
+			this.persistProviderChange(provider, undefined);
+		} else {
+			const next = remaining.length === 1 ? remaining[0] : remaining;
+			this.data[provider] = next;
+			this.persistProviderChange(provider, next);
+		}
+		this.providerRoundRobinIndex.delete(provider);
+		this.credentialBackoff.delete(provider);
+		this.providerBackoff.delete(provider);
+		return true;
+	}
+
 	/**
 	 * Get all credentials (for passing to getOAuthApiKey).
 	 * Returns normalized format where each provider has a single credential

package/packages/pi-coding-agent/src/core/chat-controller-ordering.test.ts

@@ -62,7 +62,10 @@ function createHost() {
 		defaultEditor: { onEscape: undefined },
 		editor: {},
 		session: { retryAttempt: 0, abortCompaction: () => {}, abortRetry: () => {} },
-		ui: { requestRender: () => {}, terminal: { rows: 50 } },
+		// rows:1 keeps the pinned-zone off-screen-threshold at its floor (1) so
+		// any rendered segment after a pinnable text block triggers the pin.
+		// Real terminals are larger; see chat-controller rowsRenderedAfterContentIndex.
+		ui: { requestRender: () => {}, terminal: { rows: 1, columns: 80 } },
 		footer: { invalidate: () => {} },
 		keybindings: {},
 		statusContainer: { clear: () => {}, addChild: () => {} },

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
@@ -237,6 +259,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 {
@@ -686,7 +829,10 @@ export class ExtensionRunner {
 		return currentMessages;
 	}
 
-	async emitBeforeProviderRequest(payload: unknown, model?: { provider: string; id: string }): Promise<unknown> {
+	async emitBeforeProviderRequest(
+		payload: unknown,
+		model?: { provider: string; id: string; api?: string },
+	): Promise<unknown> {
 		let currentPayload = payload;
 
 		await this.invokeHandlers("before_provider_request", () => ({
@@ -822,4 +968,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 };