@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

package/src/eval/py/tool-bridge.ts

@@ -30,6 +30,48 @@ interface BridgeServer {
 const registrations = new Map<string, PyToolBridgeEntry>();
 let serverPromise: Promise<BridgeServer> | null = null;
 
+/**
+ * Forward a bridge call to {@link callSessionTool}, but resolve the HTTP request
+ * the instant the cell's signal aborts instead of waiting for the tool/subagent
+ * to fully tear down.
+ *
+ * The kernel invokes this bridge with a *blocking* `urllib` request from a
+ * worker thread (each `agent()` / `tool.*` call). When the cell is interrupted,
+ * `parallel()`'s `ThreadPoolExecutor.__exit__` joins those worker threads
+ * (`shutdown(wait=True)`), so they cannot unwind until their `urllib` call
+ * returns — i.e. until this handler responds. A host-side `agent()` teardown
+ * (aborting nested LLM streams + tools across a wide fan-out) routinely exceeds
+ * the kernel's SIGINT escalation window, so the kernel was hard-killed and its
+ * persistent state lost while the subagents were still winding down. Responding
+ * immediately on abort lets the kernel raise through the blocked call and settle
+ * cleanly (preserving state); the already-signaled call keeps tearing down in
+ * the background, its eventual result/rejection swallowed.
+ */
+async function callSessionToolPromptOnAbort(name: string, args: unknown, entry: PyToolBridgeEntry): Promise<unknown> {
+	const call = callSessionTool(name, args, {
+		session: entry.toolSession,
+		signal: entry.signal,
+		emitStatus: entry.emitStatus,
+	});
+	const signal = entry.signal;
+	if (!signal) return await call;
+	if (signal.aborted) {
+		void call.catch(() => {});
+		throw new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`);
+	}
+	const { promise: aborted, reject } = Promise.withResolvers<never>();
+	const onAbort = () => reject(new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`));
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await Promise.race([call, aborted]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		// `call` may still be settling (subagent teardown after its own abort);
+		// swallow its outcome so an abort-won race can't surface as unhandled.
+		void call.catch(() => {});
+	}
+}
+
 async function startServer(): Promise<BridgeServer> {
 	const token = crypto.randomUUID();
 	const server = Bun.serve({
@@ -66,11 +108,7 @@ async function startServer(): Promise<BridgeServer> {
 			}
 
 			try {
-				const value = await callSessionTool(name, body.args, {
-					session: entry.toolSession,
-					signal: entry.signal,
-					emitStatus: entry.emitStatus,
-				});
+				const value = await callSessionToolPromptOnAbort(name, body.args, entry);
 				return Response.json({ ok: true, value });
 			} catch (err) {
 				return Response.json({

package/src/export/ttsr.ts

@@ -294,6 +294,9 @@ export class TtsrManager {
 
 	/** Add a TTSR rule to be monitored. */
 	addRule(rule: Rule): boolean {
+		if (!this.#settings.enabled) {
+			return false;
+		}
 		if (this.#rules.has(rule.name)) {
 			return false;
 		}
@@ -357,6 +360,9 @@ export class TtsrManager {
 	}
 
 	#matchBuffer(buffer: string, context: TtsrMatchContext): Rule[] {
+		if (!this.#settings.enabled) {
+			return [];
+		}
 		const matches: Rule[] = [];
 		for (const [name, entry] of this.#rules) {
 			if (!this.#canTrigger(name)) {
@@ -433,6 +439,9 @@ export class TtsrManager {
 
 	/** Check if any TTSR rules are registered. */
 	hasRules(): boolean {
+		if (!this.#settings.enabled) {
+			return false;
+		}
 		return this.#rules.size > 0;
 	}
 

package/src/extensibility/custom-commands/bundled/ci-green/index.ts

@@ -12,6 +12,35 @@ async function getHeadTag(api: CustomCommandAPI): Promise<string | undefined> {
 	}
 }
 
+async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
+	try {
+		return (await git.branch.current(api.cwd)) ?? "HEAD";
+	} catch {
+		return "HEAD";
+	}
+}
+
+async function getPushRemote(api: CustomCommandAPI, branch: string): Promise<string | undefined> {
+	try {
+		return (
+			(await git.config.getBranch(api.cwd, branch, "pushRemote")) ??
+			(await git.config.getBranch(api.cwd, branch, "remote"))
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+async function getHeadTagContext(api: CustomCommandAPI): Promise<{ branch: string; headTag?: string; remote: string }> {
+	const branch = await getCurrentBranch(api);
+	const [headTag, pushRemote] = await Promise.all([getHeadTag(api), getPushRemote(api, branch)]);
+	return {
+		headTag,
+		branch,
+		remote: pushRemote ?? "origin",
+	};
+}
+
 export class GreenCommand implements CustomCommand {
 	name = "green";
 	description = "Generate a prompt to iterate on CI failures until the branch is green";
@@ -19,7 +48,7 @@ export class GreenCommand implements CustomCommand {
 	constructor(private api: CustomCommandAPI) {}
 
 	async execute(_args: string[], _ctx: HookCommandContext): Promise<string> {
-		const headTag = await getHeadTag(this.api);
-		return prompt.render(ciGreenRequestTemplate, { headTag });
+		const { headTag, branch, remote } = await getHeadTagContext(this.api);
+		return prompt.render(ciGreenRequestTemplate, { headTag, branch, remote });
 	}
 }

package/src/extensibility/extensions/runner.ts

@@ -354,6 +354,8 @@ export class ExtensionRunner {
 		"ctrl+o": true,
 		"ctrl+t": true,
 		"ctrl+g": true,
+		// Default chord for `app.message.followUp` (Windows Terminal can't deliver Ctrl+Enter; #1903).
+		"ctrl+q": true,
 		"shift+tab": true,
 		"shift+ctrl+p": true,
 		"alt+enter": true,