@oh-my-pi/pi-coding-agent 15.9.1 → 15.9.5

package/src/cli/plugin-cli.ts

@@ -354,6 +354,7 @@ async function handleInstall(
 		console.error(chalk.dim(`  ${APP_NAME} plugin install name@marketplace`));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install github:user/repo`));
 		console.error(chalk.dim(`  ${APP_NAME} plugin install https://github.com/user/repo#v1.0`));
+		console.error(chalk.dim(`  ${APP_NAME} plugin install ./path/to/local/plugin`));
 		process.exit(1);
 	}
 
@@ -382,6 +383,49 @@ async function handleInstall(
 			continue;
 		}
 
+		if (target.type === "local") {
+			// Local paths route to link(): symlink the directory into the plugins
+			// node_modules tree so source edits show up without a reinstall. Matches
+			// `omp plugin link <path>` so users can use either verb interchangeably.
+			if (flags.scope) {
+				console.error(
+					chalk.yellow(
+						`Warning: --scope is only supported for marketplace installs (name@marketplace). Ignoring for ${spec}.`,
+					),
+				);
+			}
+			if (flags.force) {
+				console.error(
+					chalk.yellow(
+						`Warning: --force has no effect for local path installs (link is already idempotent). Ignoring for ${spec}.`,
+					),
+				);
+			}
+			if (flags.dryRun) {
+				if (flags.json) {
+					console.log(JSON.stringify({ dryRun: true, action: "link", path: target.path }, null, 2));
+				} else {
+					console.log(chalk.dim(`[dry-run] Would link ${spec}`));
+				}
+				continue;
+			}
+			try {
+				const result = await manager.link(target.path);
+				if (flags.json) {
+					console.log(JSON.stringify(result, null, 2));
+				} else {
+					console.log(chalk.green(`${theme.status.success} Linked ${result.name} from ${spec}`));
+					if (result.manifest.description) {
+						console.log(chalk.dim(`  ${result.manifest.description}`));
+					}
+				}
+			} catch (err) {
+				console.error(chalk.red(`${theme.status.error} Failed to install ${spec}: ${err}`));
+				process.exit(1);
+			}
+			continue;
+		}
+
 		// --scope only applies to marketplace installs; warn when it would be silently no-op'd for npm.
 		if (flags.scope) {
 			console.error(
@@ -923,6 +967,7 @@ ${chalk.bold("Sources:")}
   github:user/repo[#ref]          GitHub shorthand (also gitlab:, bitbucket:, codeberg:, sourcehut:)
   https://github.com/user/repo    Full git URL (https, ssh, or git protocol)
   name@marketplace                Marketplace plugin (see marketplace command)
+  ./path, ../path, /abs, ~/path   Local plugin directory (symlinked, same as plugin link)
 
 ${chalk.bold("Config Subcommands:")}
   config list <pkg>              List all settings

package/src/cli/web-search-cli.ts

@@ -97,7 +97,6 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	const result = await runSearchQuery(params);
 	const component = renderSearchResult(result, { expanded: cmd.expanded, isPartial: false }, theme, {
 		query: cmd.query,
-		allowLongAnswer: true,
 		maxAnswerLines: cmd.expanded ? undefined : 6,
 	});
 

package/src/cli-commands.ts

@@ -20,6 +20,7 @@ export const commands: CommandEntry[] = [
 	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
 	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
+	{ name: "dry-balance", load: () => import("./commands/dry-balance").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
 	{ name: "install", load: () => import("./commands/install").then(m => m.default) },

package/src/commands/dry-balance.ts

@@ -0,0 +1,43 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runDryBalanceCommand } from "../cli/dry-balance-cli";
+
+export default class DryBalance extends Command {
+	static description = "Dry-run OAuth account balancing across random session ids";
+
+	static args = {
+		model: Args.string({
+			description: "Model selector (provider/model or fuzzy id). Defaults to the configured default model.",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		model: Flags.string({ description: "Model selector (same syntax as --model on omp)" }),
+		count: Flags.integer({ description: "Number of random session ids to try", default: 100 }),
+		concurrency: Flags.integer({ description: "Maximum concurrent credential resolutions", default: 32 }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		bench: Flags.boolean({ description: "Send one live benchmark request per OAuth account" }),
+	};
+
+	static examples = [
+		"# Dry-run the configured default model with 100 random session ids\n  omp dry-balance",
+		"# Dry-run a specific model\n  omp dry-balance anthropic/claude-sonnet-4-5",
+		"# Larger run with bounded concurrency\n  omp dry-balance --model openai-codex/gpt-5-codex --count 1000 --concurrency 64",
+		"# Benchmark every OAuth account in parallel\n  omp dry-balance --bench",
+		"# Machine-readable output\n  omp dry-balance --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(DryBalance);
+		await runDryBalanceCommand({
+			model: args.model,
+			flags: {
+				model: flags.model,
+				count: flags.count,
+				concurrency: flags.concurrency,
+				json: flags.json,
+				bench: flags.bench,
+			},
+		});
+	}
+}

package/src/config/model-registry.ts

@@ -38,6 +38,45 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 // "socket connection was closed unexpectedly").
 const DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
 
+const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+const OLLAMA_HOST_DEFAULT_PORT = "11434";
+
+function normalizeOllamaHostEnv(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	const candidate = trimmed.includes("://")
+		? trimmed
+		: trimmed.startsWith("//")
+			? `http:${trimmed}`
+			: trimmed.startsWith(":")
+				? `http://127.0.0.1${trimmed}`
+				: `http://${trimmed}`;
+	try {
+		const parsed = new URL(candidate);
+		if (!parsed.hostname || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
+			return undefined;
+		}
+		if (!parsed.port && parsed.protocol === "http:") {
+			parsed.port = OLLAMA_HOST_DEFAULT_PORT;
+		}
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return undefined;
+	}
+}
+
+function getImplicitOllamaBaseUrl(): string {
+	const baseUrl = Bun.env.OLLAMA_BASE_URL?.trim();
+	return baseUrl || normalizeOllamaHostEnv(Bun.env.OLLAMA_HOST) || DEFAULT_OLLAMA_BASE_URL;
+}
+
+function getOllamaContextLengthOverride(): number | undefined {
+	const value = Bun.env.OLLAMA_CONTEXT_LENGTH?.trim();
+	if (!value) return undefined;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 // Anthropic-safe variant of the discovery cap. The Anthropic stream converter
 // in `packages/ai/src/providers/anthropic.ts` derives the request limit as
 // `(model.maxTokens / 3) | 0`, so the 32K default would surface as 10,922
@@ -547,6 +586,7 @@ function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<A
 	if (override.input !== undefined) result.input = override.input as ("text" | "image")[];
 	if (override.contextWindow !== undefined) result.contextWindow = override.contextWindow;
 	if (override.maxTokens !== undefined) result.maxTokens = override.maxTokens;
+	if (override.omitMaxOutputTokens !== undefined) result.omitMaxOutputTokens = override.omitMaxOutputTokens;
 	if (override.contextPromotionTarget !== undefined) result.contextPromotionTarget = override.contextPromotionTarget;
 	if (override.premiumMultiplier !== undefined) result.premiumMultiplier = override.premiumMultiplier;
 	if (override.cost) {
@@ -575,6 +615,7 @@ interface CustomModelDefinitionLike {
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
+	omitMaxOutputTokens?: boolean;
 	headers?: Record<string, string>;
 	compat?: Model<Api>["compat"];
 	contextPromotionTarget?: string;
@@ -597,6 +638,7 @@ type CustomModelOverlay = {
 	cost?: { input: number; output: number; cacheRead: number; cacheWrite: number };
 	contextWindow?: number;
 	maxTokens?: number;
+	omitMaxOutputTokens?: boolean;
 	headers?: Record<string, string>;
 	compat?: Model<Api>["compat"];
 	contextPromotionTarget?: string;
@@ -667,6 +709,7 @@ function buildCustomModelOverlay(
 		cost: modelDef.cost,
 		contextWindow: modelDef.contextWindow,
 		maxTokens: modelDef.maxTokens,
+		omitMaxOutputTokens: modelDef.omitMaxOutputTokens,
 		headers: mergeCustomModelHeaders(providerHeaders, modelDef.headers, authHeader, providerApiKey),
 		compat: mergeCompat(providerCompat, modelDef.compat),
 		contextPromotionTarget: modelDef.contextPromotionTarget,
@@ -823,6 +866,7 @@ function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuil
 			resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : undefined),
 		maxTokens: resolvedModel.maxTokens ?? reference?.maxTokens ?? (options.useDefaults ? 16384 : undefined),
 		headers: resolvedModel.headers,
+		omitMaxOutputTokens: resolvedModel.omitMaxOutputTokens ?? reference?.omitMaxOutputTokens,
 		compat: mergeCompat(reference?.compat, resolvedModel.compat),
 		contextPromotionTarget: resolvedModel.contextPromotionTarget,
 		premiumMultiplier: resolvedModel.premiumMultiplier,
@@ -1124,6 +1168,7 @@ export class ModelRegistry {
 					cost: customModel.cost ?? existingModel.cost,
 					contextWindow: customModel.contextWindow ?? existingModel.contextWindow,
 					maxTokens: customModel.maxTokens ?? existingModel.maxTokens,
+					omitMaxOutputTokens: customModel.omitMaxOutputTokens ?? existingModel.omitMaxOutputTokens,
 					// Same-id custom definitions replace bundled transport behavior. Provider-level
 					// headers/compat were already folded into customModel during parsing; do not
 					// re-merge bundled transport metadata here.
@@ -1214,7 +1259,18 @@ export class ModelRegistry {
 			return models;
 		}
 
-		return models.map(model => (model.api === "openai-completions" ? { ...model, api: "openai-responses" } : model));
+		const contextLengthOverride = getOllamaContextLengthOverride();
+		return models.map(model => {
+			const normalized = model.api === "openai-completions" ? { ...model, api: "openai-responses" as const } : model;
+			if (contextLengthOverride === undefined) {
+				return normalized;
+			}
+			return {
+				...normalized,
+				contextWindow: contextLengthOverride,
+				maxTokens: Math.min(contextLengthOverride, DISCOVERY_DEFAULT_MAX_TOKENS),
+			};
+		});
 	}
 
 	#addImplicitDiscoverableProviders(configuredProviders: Set<string>): void {
@@ -1223,7 +1279,7 @@ export class ModelRegistry {
 			this.#discoverableProviders.push({
 				provider: "ollama",
 				api: "openai-responses",
-				baseUrl: Bun.env.OLLAMA_BASE_URL || "http://127.0.0.1:11434",
+				baseUrl: getImplicitOllamaBaseUrl(),
 				discovery: { type: "ollama" },
 				optional: true,
 			});
@@ -1987,12 +2043,12 @@ export class ModelRegistry {
 		}
 	}
 	#normalizeOllamaBaseUrl(baseUrl?: string): string {
-		const raw = baseUrl || "http://127.0.0.1:11434";
+		const raw = baseUrl || DEFAULT_OLLAMA_BASE_URL;
 		try {
 			const parsed = new URL(raw);
 			return `${parsed.protocol}//${parsed.host}`;
 		} catch {
-			return "http://127.0.0.1:11434";
+			return DEFAULT_OLLAMA_BASE_URL;
 		}
 	}
 

package/src/config/models-config-schema.ts

@@ -93,6 +93,7 @@ const ModelDefinitionSchema = z.object({
 	premiumMultiplier: z.number().optional(),
 	contextWindow: z.number().optional(),
 	maxTokens: z.number().optional(),
+	omitMaxOutputTokens: z.boolean().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	compat: OpenAICompatSchema.optional(),
 	contextPromotionTarget: z.string().min(1).optional(),
@@ -114,6 +115,7 @@ export const ModelOverrideSchema = z.object({
 	premiumMultiplier: z.number().optional(),
 	contextWindow: z.number().optional(),
 	maxTokens: z.number().optional(),
+	omitMaxOutputTokens: z.boolean().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	compat: OpenAICompatSchema.optional(),
 	contextPromotionTarget: z.string().min(1).optional(),

package/src/config/settings-schema.ts

@@ -635,7 +635,7 @@ export const SETTINGS_SCHEMA = {
 			tab: "appearance",
 			label: "Terminal Hyperlinks",
 			description:
-				"Wrap file paths in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
+				"Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)",
 		},
 	},
 	// Display rendering
@@ -722,6 +722,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	includeModelInPrompt: {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			label: "Include Model In Prompt",
+			description: "Surface the active model identifier in the system prompt so the agent knows which model it is",
+		},
+	},
+
 	// Sampling
 	temperature: {
 		type: "number",
@@ -2483,13 +2493,13 @@ export const SETTINGS_SCHEMA = {
 	// Tool Discovery
 	"tools.discoveryMode": {
 		type: "enum",
-		values: ["off", "mcp-only", "all"] as const,
-		default: "off",
+		values: ["auto", "off", "mcp-only", "all"] as const,
+		default: "auto",
 		ui: {
 			tab: "tools",
 			label: "Tool Discovery",
 			description:
-				"Hide tools behind a search tool to save tokens. 'mcp-only' hides MCP tools; 'all' hides all non-essential built-ins too.",
+				"Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.",
 		},
 	},
 

package/src/config/settings.ts

@@ -907,6 +907,9 @@ const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
 			for (const cb of appendOnlyModeCallbacks) cb(value);
 		}
 	},
+	"hindsight.bankId": () => fireHindsightScopeChanged(),
+	"hindsight.bankIdPrefix": () => fireHindsightScopeChanged(),
+	"hindsight.scoping": () => fireHindsightScopeChanged(),
 };
 /** Callbacks invoked when `provider.appendOnlyContext` changes at runtime. */
 const appendOnlyModeCallbacks = new Set<(value: string) => void>();
@@ -923,6 +926,41 @@ export function onAppendOnlyModeChanged(cb: (value: string) => void): () => void
 	};
 }
 
+/** Callbacks fired when any `hindsight.bankId` / `bankIdPrefix` / `scoping` value changes. */
+const hindsightScopeCallbacks = new Set<() => void>();
+
+function fireHindsightScopeChanged(): void {
+	// Snapshot the callback set before invoking — a callback's body is allowed
+	// to subscribe a NEW callback (the Hindsight backend re-registers the
+	// fresh state's listener on every rebuild). Iterating the live Set would
+	// re-invoke those just-added callbacks within the same fire, which spins
+	// in place: subscribe → invoke → subscribe → invoke → …
+	for (const cb of [...hindsightScopeCallbacks]) {
+		try {
+			cb();
+		} catch (err) {
+			logger.warn("Settings: hindsight scope hook failed", { error: String(err) });
+		}
+	}
+}
+
+/**
+ * Subscribe to changes in the Hindsight bank-scoping settings. Lets the
+ * Hindsight backend rebuild the active `HindsightSessionState` when the
+ * operator switches `hindsight.bankId`, `hindsight.bankIdPrefix`, or
+ * `hindsight.scoping` mid-session so subsequent retain/recall calls land in
+ * the new bank instead of the one selected at session start.
+ *
+ * Returns an unsubscribe function. The callback receives no arguments — the
+ * caller is expected to re-read the relevant settings via `Settings.get`.
+ */
+export function onHindsightScopeChanged(cb: () => void): () => void {
+	hindsightScopeCallbacks.add(cb);
+	return () => {
+		hindsightScopeCallbacks.delete(cb);
+	};
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Global Singleton
 // ═══════════════════════════════════════════════════════════════════════════

package/src/discovery/builtin-rules/ts-no-tiny-functions.md

@@ -46,5 +46,6 @@ const doubled = value * 2;
 - Callback identity matters.
 - Type guard preserves narrowing.
 - Public API, test seam, or DI boundary needs indirection.
+- Names a non-obvious formula or magic-constant computation that the inlined expression would not explain on its own.
 
 If none apply, inline it.

package/src/discovery/github.ts

@@ -10,6 +10,7 @@
  * Capabilities:
  * - context-files: copilot-instructions.md in .github/
  * - instructions: *.instructions.md in .github/instructions/ with applyTo frontmatter
+ * - skills: <name>/SKILL.md in .github/skills/ (GitHub Agent Skills layout)
  */
 import * as path from "node:path";
 import { parseFrontmatter } from "@oh-my-pi/pi-utils";
@@ -17,9 +18,10 @@ import { registerProvider } from "../capability";
 import { type ContextFile, contextFileCapability } from "../capability/context-file";
 import { readFile } from "../capability/fs";
 import { type Instruction, instructionCapability } from "../capability/instruction";
+import { type Skill, skillCapability } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
-import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir } from "./helpers";
+import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
 
 const PROVIDER_ID = "github";
 const DISPLAY_NAME = "GitHub Copilot";
@@ -97,6 +99,32 @@ function transformInstruction(name: string, content: string, filePath: string, s
 	};
 }
 
+// =============================================================================
+// Skills
+// =============================================================================
+
+/**
+ * Load skills from `.github/skills/<name>/SKILL.md`.
+ *
+ * GitHub documents this layout for Copilot Agent Skills and matches the
+ * non-recursive shape `scanSkillsFromDir` already expects. `requireDescription`
+ * is on to match the Agent Skills spec (name + description are mandatory) and
+ * the sibling `native`/`omp-plugins` providers.
+ *
+ * @see https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/add-skills
+ */
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const skillsDir = getProjectPath(ctx, "github", "skills");
+	if (!skillsDir) return { items: [], warnings: [] };
+
+	return scanSkillsFromDir(ctx, {
+		dir: skillsDir,
+		providerId: PROVIDER_ID,
+		level: "project",
+		requireDescription: true,
+	});
+}
+
 // =============================================================================
 // Provider Registration
 // =============================================================================
@@ -116,3 +144,11 @@ registerProvider(instructionCapability.id, {
 	priority: PRIORITY,
 	load: loadInstructions,
 });
+
+registerProvider<Skill>(skillCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load skills from .github/skills/*/SKILL.md",
+	priority: PRIORITY,
+	load: loadSkills,
+});

package/src/discovery/helpers.ts

@@ -212,6 +212,7 @@ export interface ParsedAgentFields {
 	output?: unknown;
 	thinkingLevel?: ThinkingLevel;
 	autoloadSkills?: string[];
+	readSummarize?: boolean;
 	blocking?: boolean;
 }
 
@@ -265,10 +266,11 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	const thinkingLevel = parseThinkingLevel(rawThinkingLevel);
 	const model = parseModelList(frontmatter.model);
 	const blocking = parseBoolean(frontmatter.blocking);
+	const readSummarize = parseBoolean(frontmatter.readSummarize);
 	const autoloadSkills = parseArrayOrCSV(frontmatter.autoloadSkills)
 		?.map(s => s.trim())
 		.filter(Boolean);
-	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills };
+	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills, readSummarize };
 }
 
 async function globIf(

package/src/eval/__tests__/agent-bridge.test.ts

@@ -397,6 +397,78 @@ describe("agent() through eval runtimes", () => {
 		expect(maxInFlight).toBeLessThanOrEqual(2);
 	});
 
+	it("interrupting a Python parallel() fan-out settles the kernel cleanly and preserves session state", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-interrupt-");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 6,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-interrupt", settings);
+		mockAgents();
+		// Subagents that ignore the abort for far longer than the kernel's SIGINT
+		// escalation window. Each kernel worker thread blocks in a synchronous
+		// `urllib` bridge call, joined by `parallel()`'s ThreadPoolExecutor exit.
+		// The host must respond the instant the cell aborts so the kernel can
+		// unwind via KeyboardInterrupt instead of being hard-killed (which used to
+		// surface "[kernel] Python kernel shutdown" and lose all session state).
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			await Bun.sleep(9000); // deliberately ignores options.signal
+			return singleResult(options, { output: options.assignment ?? "" });
+		});
+
+		// Seed persistent session state and confirm the kernel is reusable.
+		const seed = await executePython("PREP_MARKER = 4242", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		if (seed.exitCode === undefined && seed.cancelled) {
+			expect(seed.output).toBe("");
+			return; // kernel unavailable in this environment
+		}
+		expect(seed.exitCode).toBe(0);
+
+		const ac = new AbortController();
+		// Abort ~1s in, after the worker threads are blocked in their bridge calls.
+		setTimeout(() => ac.abort(new Error("external interrupt")), 1000);
+
+		const start = Date.now();
+		const result = await executePython(
+			"import json\nprint(json.dumps(parallel([lambda n=n: agent(str(n)) for n in range(12)])))",
+			{
+				cwd: tempDir.path(),
+				sessionId,
+				sessionFile,
+				kernelMode: "session",
+				toolSession: session,
+				idleTimeoutMs: 60_000,
+				signal: ac.signal,
+			},
+		);
+		const elapsed = Date.now() - start;
+
+		// Cancelled, but cleanly: no hard-kill, settled well within the kernel's 5s
+		// SIGINT escalation window rather than ~6s after it.
+		expect(result.cancelled).toBe(true);
+		expect(result.output).not.toContain("Python kernel shutdown");
+		expect(elapsed).toBeLessThan(4000);
+
+		// The persistent kernel survived the interrupt: prior state is intact.
+		const after = await executePython("print(PREP_MARKER)", {
+			cwd: tempDir.path(),
+			sessionId,
+			sessionFile,
+			kernelMode: "session",
+			toolSession: session,
+		});
+		expect(after.exitCode).toBe(0);
+		expect(after.output.trim()).toBe("4242");
+	}, 30_000);
+
 	it("streams enriched agent progress through onStatus before the cell finishes", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-progress-");
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-progress");

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/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 });
 	}
 }