jeopi-cli 16.4.2 → 16.4.4

package/src/config/settings-schema.ts

@@ -1262,7 +1262,7 @@ export const SETTINGS_SCHEMA = {
 	textVerbosity: {
 		type: "enum",
 		values: ["low", "medium", "high"] as const,
-		default: "high",
+		default: "medium",
 		ui: {
 			tab: "model",
 			group: "Sampling",
@@ -1270,8 +1270,8 @@ export const SETTINGS_SCHEMA = {
 			description: "OpenAI Responses and Codex response verbosity (low, medium, or high)",
 			options: [
 				{ value: "low", label: "Low", description: "Prefer concise responses" },
-				{ value: "medium", label: "Medium", description: "Balance brevity and detail" },
-				{ value: "high", label: "High", description: "Prefer detailed responses (default)" },
+				{ value: "medium", label: "Medium", description: "Balance brevity and detail (default)" },
+				{ value: "high", label: "High", description: "Prefer detailed responses" },
 			],
 		},
 	},
@@ -3189,18 +3189,6 @@ export const SETTINGS_SCHEMA = {
 	},
 	"bashInterceptor.patterns": { type: "array", default: DEFAULT_BASH_INTERCEPTOR_RULES },
 
-	"bash.stripTrailingHeadTail": {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "shell",
-			group: "Bash",
-			label: "Strip head/tail Pipes",
-			description:
-				"Silently drop trailing `| head`/`| tail` pipes from single-line bash commands. Output is already truncated automatically.",
-		},
-	},
-
 	// Shell output minimizer
 	"shellMinimizer.enabled": {
 		type: "boolean",

package/src/edit/index.ts

@@ -4,19 +4,13 @@ import { MismatchError as HashlineMismatchError } from "jeopi-hashline";
 import hashlineGrammar from "jeopi-hashline/grammar.lark" with { type: "text" };
 import hashlineDescription from "jeopi-hashline/prompt.md" with { type: "text" };
 import { prompt } from "jeopi-utils";
-import {
-	createLspWritethrough,
-	type FileDiagnosticsResult,
-	flushLspWritethroughBatch,
-	type WritethroughCallback,
-	type WritethroughDeferredHandle,
-	writethroughNoop,
-} from "../lsp";
+import { createLspWritethrough, flushLspWritethroughBatch, type WritethroughCallback, writethroughNoop } from "../lsp";
+import { DeferredDiagnostics } from "../lsp/deferred-diagnostics";
 import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
-import type { DeferredDiagnosticsEntry, ToolSession } from "../tools";
+import type { ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
 import { withPathWriteLock } from "../tools/path-write-lock";
@@ -385,12 +379,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
 	readonly #editMode?: EditMode;
-	readonly #dedupDiagnostics: boolean;
-	readonly #pendingDeferredFetches = new Map<string, AbortController>();
-	/** Fallback per-path mutation counter used only when the session does not expose
-	 *  a shared one. Prefer `session.bumpFileMutationVersion` so write (and any other
-	 *  tool) mutating the same file also invalidates pending late-diagnostics. */
-	readonly #editVersionByPath = new Map<string, number>();
+	readonly #deferredDiagnostics: DeferredDiagnostics;
 
 	constructor(private readonly session: ToolSession) {
 		const {
@@ -402,10 +391,11 @@ export class EditTool implements AgentTool<TInput> {
 		this.#editMode = resolveConfiguredEditMode(envEditVariant);
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
-		this.#dedupDiagnostics =
+		const deduplicateDiagnostics =
 			(session.enableLsp ?? true) &&
 			session.settings.get("lsp.diagnosticsOnEdit") &&
 			session.settings.get("lsp.diagnosticsDeduplicate");
+		this.#deferredDiagnostics = new DeferredDiagnostics(session, deduplicateDiagnostics);
 		this.#writethrough = withPathWriteLock(createEditWritethrough(session));
 	}
 
@@ -550,7 +540,7 @@ export class EditTool implements AgentTool<TInput> {
 								// doubles as the documented full-file overwrite (patch.md <avoid>).
 								allowCreateOverwrite: true,
 								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+								beginDeferredDiagnosticsForPath: p => tool.#deferredDiagnostics.begin(p),
 							}),
 					);
 					return executeSinglePathEntries(path, runs, batchRequest, onUpdate, tool.session.cwd, signal);
@@ -589,7 +579,7 @@ export class EditTool implements AgentTool<TInput> {
 									allowFuzzy: tool.#allowFuzzy,
 									fuzzyThreshold: tool.#fuzzyThreshold,
 									writethrough: tool.#writethrough,
-									beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+									beginDeferredDiagnosticsForPath: p => tool.#deferredDiagnostics.begin(p),
 								}),
 						};
 					});
@@ -613,7 +603,7 @@ export class EditTool implements AgentTool<TInput> {
 						signal,
 						batchRequest,
 						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+						beginDeferredDiagnosticsForPath: p => tool.#deferredDiagnostics.begin(p),
 					});
 				},
 			},
@@ -639,7 +629,7 @@ export class EditTool implements AgentTool<TInput> {
 								allowFuzzy: tool.#allowFuzzy,
 								fuzzyThreshold: tool.#fuzzyThreshold,
 								writethrough: tool.#writethrough,
-								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+								beginDeferredDiagnosticsForPath: p => tool.#deferredDiagnostics.begin(p),
 							}),
 					);
 					return executeSinglePathEntries(path, runs, batchRequest, onUpdate, tool.session.cwd, signal);
@@ -647,60 +637,4 @@ export class EditTool implements AgentTool<TInput> {
 			},
 		}[this.mode];
 	}
-
-	#beginDeferredDiagnosticsForPath(path: string): WritethroughDeferredHandle {
-		const existingDeferred = this.#pendingDeferredFetches.get(path);
-		if (existingDeferred) {
-			existingDeferred.abort();
-			this.#pendingDeferredFetches.delete(path);
-		}
-
-		const deferredController = new AbortController();
-		const editVersion = this.#bumpFileVersion(path);
-		return {
-			onDeferredDiagnostics: (lateDiagnostics: FileDiagnosticsResult) => {
-				this.#pendingDeferredFetches.delete(path);
-				this.#injectLateDiagnostics(path, lateDiagnostics, editVersion);
-			},
-			signal: deferredController.signal,
-			finalize: (diagnostics: FileDiagnosticsResult | undefined) => {
-				if (!diagnostics) {
-					this.#pendingDeferredFetches.set(path, deferredController);
-				} else {
-					deferredController.abort();
-				}
-			},
-		};
-	}
-
-	#injectLateDiagnostics(path: string, diagnostics: FileDiagnosticsResult, editVersion: number): void {
-		const effective = this.#dedupDiagnostics
-			? getDiagnosticsLedger(this.session).reduce(path, diagnostics)
-			: diagnostics;
-		if (this.#dedupDiagnostics && effective.messages.length === 0) return;
-
-		const entry: DeferredDiagnosticsEntry = {
-			path,
-			summary: effective.summary ?? "",
-			messages: effective.messages ?? [],
-			errored: effective.errored,
-			// Drop at flush time if a later edit to the same file superseded this fetch.
-			isStale: () => this.#fileVersion(path) !== editVersion,
-		};
-		this.session.queueDeferredDiagnostics?.(entry);
-	}
-
-	/** Bump the file's mutation counter (session-global when available). */
-	#bumpFileVersion(path: string): number {
-		if (this.session.bumpFileMutationVersion) return this.session.bumpFileMutationVersion(path);
-		const next = (this.#editVersionByPath.get(path) ?? 0) + 1;
-		this.#editVersionByPath.set(path, next);
-		return next;
-	}
-
-	/** Read the file's current mutation counter (session-global when available). */
-	#fileVersion(path: string): number {
-		if (this.session.getFileMutationVersion) return this.session.getFileMutationVersion(path);
-		return this.#editVersionByPath.get(path) ?? 0;
-	}
 }

package/src/edit/renderer.ts

@@ -419,22 +419,25 @@ function formatStreamingDiff(
 	cache?: RenderedStringCache,
 ): string {
 	if (!diff) return "";
-	// Clamp the collapsed tail to the viewport so a tall or fast-growing diff
-	// cannot outgrow the live window. Otherwise its mutating tail scrolls above
-	// the native-scrollback commit boundary and the engine re-commits a fresh
-	// snapshot every streamed frame, stacking duplicate "… more lines above"
-	// previews in history. The budget is VISUAL rows (a long wrapped line counts
+	// Clamp the tail to the viewport so a tall or fast-growing diff cannot
+	// outgrow the live window. Otherwise its mutating rows scroll above the
+	// native-scrollback commit boundary mid-stream and freeze into immutable
+	// history as a stale preview snapshot; the finalize repair then recommits
+	// the final render below it — a duplicated block on the tape. Collapsed
+	// gets a short fixed tail; expanded widens it to the viewport-sized window,
+	// never unbounded. The budget is VISUAL rows (a long wrapped line counts
 	// for more than one) at the framed block's inner width (border only —
-	// contentPaddingLeft is 0); only the visible suffix is syntax-colored, so the
-	// cheap raw-line wrap walk keeps the per-chunk cost bounded. innerWidth/budget
-	// are in the cache salt so a resize re-slices.
+	// contentPaddingLeft is 0); only the visible suffix is syntax-colored, so
+	// the cheap raw-line wrap walk keeps the per-chunk cost bounded.
+	// innerWidth/budget are in the cache salt so a resize re-slices.
 	const innerWidth = Math.max(1, width - 2);
-	const budget = expanded ? Number.POSITIVE_INFINITY : Math.min(EDIT_STREAMING_PREVIEW_LINES, previewWindowRows());
+	const budget = expanded ? previewWindowRows() : Math.min(EDIT_STREAMING_PREVIEW_LINES, previewWindowRows());
 	let text = cachedRenderedString(cache, uiTheme, expanded, `${rawPath}:${innerWidth}:${budget}`, diff, () => {
 		// "Cursor" tail window: pin the last rows to the bottom so freshly streamed
 		// changes stay on screen. The whole-file diff is recomputed every chunk and
 		// its Myers alignment is not monotonic in payload length, so a hunk-aware
-		// window stutters as rows move between hunks. Expanded lifts the cap.
+		// window stutters as rows move between hunks. Expanded widens the window
+		// to the viewport; the full diff appears once the result finalizes.
 		const allLines = diff.replace(/\n+$/u, "").split("\n");
 		let visualUsed = 0;
 		let cut = allLines.length;

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

@@ -603,21 +603,22 @@ describe("agent() through eval runtimes", () => {
 		});
 		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).
+		// Each kernel worker thread blocks in a synchronous `urllib` bridge call,
+		// joined by `parallel()`'s ThreadPoolExecutor exit. The host must keep
+		// those already-started calls attached until they settle, then interrupt
+		// the kernel before `parallel()` launches another wave.
 		let inFlight = 0;
+		let completed = 0;
 		let markSaturated: (() => void) | undefined;
 		const saturated = new Promise<void>(resolve => {
 			markSaturated = resolve;
 		});
-		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+		const releaseAgents = Promise.withResolvers<void>();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
 			// task.maxConcurrency=6 → six bridge calls block at once; signal then.
 			if (++inFlight >= 6) markSaturated?.();
-			await Bun.sleep(9000); // deliberately ignores options.signal
+			await releaseAgents.promise;
+			completed++;
 			return singleResult(options, { output: options.assignment ?? "" });
 		});
 
@@ -640,8 +641,7 @@ describe("agent() through eval runtimes", () => {
 		// bridge calls (condition-driven) instead of waiting a fixed wall second.
 		void saturated.then(() => ac.abort(new Error("external interrupt")));
 
-		const start = Date.now();
-		const result = await executePython(
+		const resultPromise = executePython(
 			"import json\nprint(json.dumps(parallel([lambda n=n: agent(str(n)) for n in range(12)])))",
 			{
 				cwd: tempDir.path(),
@@ -653,13 +653,18 @@ describe("agent() through eval runtimes", () => {
 				signal: ac.signal,
 			},
 		);
-		const elapsed = Date.now() - start;
+		await saturated;
+		await Promise.resolve();
+		expect(completed).toBe(0);
+		releaseAgents.resolve();
+		const result = await resultPromise;
 
-		// Cancelled, but cleanly: no hard-kill, settled well within the kernel's 5s
-		// SIGINT escalation window rather than ~6s after it.
+		// Cancelled, but cleanly: no hard-kill, no orphaned bridge calls, and no
+		// second fan-out wave started after the deferred abort was delivered.
 		expect(result.cancelled).toBe(true);
 		expect(result.output).not.toContain("Python kernel shutdown");
-		expect(elapsed).toBeLessThan(4000);
+		expect(completed).toBe(6);
+		expect(runSpy).toHaveBeenCalledTimes(6);
 
 		// The persistent kernel survived the interrupt: prior state is intact.
 		const after = await executePython("print(PREP_MARKER)", {

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

@@ -5,7 +5,9 @@ import {
 	isEvalTimeoutControlEvent,
 	withBridgeTimeoutPause,
 } from "../bridge-timeout";
+import { executeWithKernelBase, type GenericKernel } from "../executor-base";
 import type { JsStatusEvent } from "../js/shared/types";
+import type { KernelDisplayOutput } from "../py/display";
 
 describe("withBridgeTimeoutPause", () => {
 	it("emits one pause before the operation and one resume after it settles", async () => {
@@ -62,3 +64,61 @@ describe("withBridgeTimeoutPause", () => {
 		expect(isEvalTimeoutControlEvent({ op: "agent", id: "subagent-1" })).toBe(false);
 	});
 });
+
+class TestCancelledError extends Error {
+	readonly timedOut: boolean;
+
+	constructor(timedOut: boolean) {
+		super(timedOut ? "timed out" : "cancelled");
+		this.name = "TestCancelledError";
+		this.timedOut = timedOut;
+	}
+}
+
+it("defers external aborts until an in-flight bridge call resumes", async () => {
+	const abortController = new AbortController();
+	const release = Promise.withResolvers<void>();
+	let completed = false;
+	let kernelSignal: AbortSignal | undefined;
+	const kernel: GenericKernel<Record<string, string | null>> = {
+		async execute(_code, options) {
+			kernelSignal = options.signal;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_PAUSE_OP },
+			} satisfies KernelDisplayOutput);
+
+			abortController.abort(new Error("external interrupt"));
+			expect(kernelSignal?.aborted).toBe(false);
+
+			await release.promise;
+			completed = true;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_RESUME_OP },
+			} satisfies KernelDisplayOutput);
+			return { status: "ok", cancelled: false, timedOut: false };
+		},
+	};
+
+	const resultPromise = executeWithKernelBase({
+		kernel,
+		code: "agent('slow')",
+		options: { signal: abortController.signal },
+		runIdPrefix: "test",
+		errorLogLabel: "test",
+		cancelledErrorClass: TestCancelledError,
+		buildKernelEnvPatch: () => ({}),
+		formatKernelTimeoutAnnotation: () => "kernel timed out",
+		formatTimeoutAnnotation: () => "timed out",
+	});
+
+	await Promise.resolve();
+	expect(completed).toBe(false);
+
+	release.resolve();
+	const result = await resultPromise;
+	expect(completed).toBe(true);
+	expect(result.cancelled).toBe(true);
+	expect(result.exitCode).toBeUndefined();
+});

package/src/eval/executor-base.ts

@@ -3,7 +3,7 @@ import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
 import type { ToolSession } from "../tools";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
-import { isEvalTimeoutControlEvent } from "./bridge-timeout";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP, isEvalTimeoutControlEvent } from "./bridge-timeout";
 import type { JsStatusEvent } from "./js/shared/types";
 import type { KernelDisplayOutput } from "./py/display";
 import { registerPyToolBridge } from "./py/tool-bridge";
@@ -158,6 +158,76 @@ export async function waitForPromiseWithCancellation<T>(
 	return await resultPromise;
 }
 
+interface BridgeAbortShield {
+	signal: AbortSignal | undefined;
+	abortRequested: boolean;
+	timedOut: boolean;
+	handleStatus?: (event: JsStatusEvent) => void;
+	dispose?: () => void;
+}
+
+function createBridgeAbortShield(source: AbortSignal | undefined): BridgeAbortShield {
+	const shield: BridgeAbortShield = {
+		signal: undefined,
+		abortRequested: false,
+		timedOut: false,
+	};
+	if (!source) return shield;
+
+	const controller = new AbortController();
+	let pauseDepth = 0;
+	let abortReason: unknown;
+	let removeAbortListener: (() => void) | undefined;
+
+	const requestAbort = (reason: unknown): void => {
+		shield.abortRequested = true;
+		shield.timedOut =
+			shield.timedOut ||
+			(typeof DOMException !== "undefined" && reason instanceof DOMException
+				? reason.name === "TimeoutError"
+				: reason instanceof Error && reason.name === "TimeoutError");
+		abortReason = reason;
+		if (pauseDepth > 0 || controller.signal.aborted) return;
+		controller.abort(reason);
+	};
+
+	const onAbort = (): void => {
+		const reason = source.reason;
+		requestAbort(reason);
+	};
+
+	shield.signal = controller.signal;
+	shield.handleStatus = (event: JsStatusEvent): void => {
+		if (event.op === EVAL_TIMEOUT_PAUSE_OP) {
+			pauseDepth++;
+			return;
+		}
+		if (event.op !== EVAL_TIMEOUT_RESUME_OP || pauseDepth === 0) return;
+		pauseDepth--;
+		if (shield.abortRequested && !controller.signal.aborted) controller.abort(abortReason);
+	};
+	shield.dispose = (): void => {
+		removeAbortListener?.();
+		removeAbortListener = undefined;
+	};
+
+	if (source.aborted) {
+		requestAbort(source.reason);
+	} else {
+		source.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => {
+			source.removeEventListener("abort", onAbort);
+		};
+		if (source.aborted) {
+			source.removeEventListener("abort", onAbort);
+			removeAbortListener = undefined;
+			requestAbort(source.reason);
+		}
+	}
+
+	return shield;
+}
+
 export function createCancelledKernelResult(output: string): KernelExecutionResult {
 	const outputBytes = Buffer.byteLength(output, "utf-8");
 	const outputLines = output.length > 0 ? 1 : 0;
@@ -304,9 +374,11 @@ export async function executeWithKernelBase<
 	const displayOutputs: KernelDisplayOutput[] = [];
 	const deadlineMs = (resolveDeadlineMs ?? getExecutionDeadlineMs)(options);
 	let executionTimeoutMs: number | undefined;
+	const abortShield = createBridgeAbortShield(options?.signal);
 
 	const collectDisplay = (output: KernelDisplayOutput): void => {
 		if (output.type === "status") {
+			abortShield.handleStatus?.(output.event);
 			options?.onStatus?.(output.event);
 			if (!isJulia && isEvalTimeoutControlEvent(output.event)) return;
 		}
@@ -320,8 +392,11 @@ export async function executeWithKernelBase<
 		options?.toolSession && options?.bridgeSessionId
 			? registerPyToolBridge(options.bridgeSessionId, runId, {
 					toolSession: options.toolSession,
-					signal: options.signal,
+					signal: abortShield.signal,
 					emitStatus,
+					abortRequested: () => {
+						return abortShield.abortRequested;
+					},
 				})
 			: null;
 
@@ -338,14 +413,15 @@ export async function executeWithKernelBase<
 			cwd: options?.cwd,
 			env: buildKernelEnvPatch(options ?? ({} as TOptions)),
 			id: runId,
-			signal: options?.signal,
+			signal: abortShield.signal,
 			timeoutMs: executionTimeoutMs,
 			onChunk: text => sink.push(text),
 			onDisplay: output => collectDisplay(output),
 		});
 
-		if (result.cancelled) {
-			const annotation = result.timedOut
+		if (result.cancelled || abortShield.abortRequested) {
+			const timedOut = result.timedOut || abortShield.timedOut;
+			const annotation = timedOut
 				? formatKernelTimeoutAnnotation(executionTimeoutMs ?? options?.idleTimeoutMs, result.kernelKilled ?? false)
 				: undefined;
 			const dumped = await sink.dump(annotation);
@@ -397,8 +473,8 @@ export async function executeWithKernelBase<
 			stdinRequested: false,
 		};
 	} catch (err) {
-		if (isCancellationError(err, cancelledErrorClass) || options?.signal?.aborted) {
-			const timedOut = isTimedOutCancellation(err, cancelledErrorClass, options?.signal);
+		if (isCancellationError(err, cancelledErrorClass) || abortShield.abortRequested || abortShield.signal?.aborted) {
+			const timedOut = abortShield.timedOut || isTimedOutCancellation(err, cancelledErrorClass, abortShield.signal);
 			const dumped = await sink.dump(
 				timedOut ? formatTimeoutAnnotation(executionTimeoutMs ?? options?.idleTimeoutMs) : undefined,
 			);
@@ -421,5 +497,6 @@ export async function executeWithKernelBase<
 		throw error;
 	} finally {
 		unregisterBridge?.();
+		abortShield.dispose?.();
 	}
 }

package/src/eval/js/shared/rewrite-imports.ts

@@ -48,6 +48,15 @@ type BabelClassDeclaration = {
 };
 
 type BabelLexicalDecl = BabelVariableDeclaration | BabelClassDeclaration;
+type BabelFunctionDeclaration = {
+	type: "FunctionDeclaration";
+	start: number;
+	end: number;
+	id: { start: number; end: number; name: string } | null;
+};
+
+/** Top-level declarations whose bindings must survive the cell (demoted and/or published). */
+type BabelPublishableDecl = BabelLexicalDecl | BabelFunctionDeclaration;
 
 type BabelExpressionStatement = {
 	type: "ExpressionStatement";
@@ -322,7 +331,7 @@ function collectBindingNames(pattern: unknown, names: string[]): void {
 	}
 }
 
-function getLexicalBindingNames(node: BabelLexicalDecl): string[] {
+function getLexicalBindingNames(node: BabelPublishableDecl): string[] {
 	const names: string[] = [];
 	if (node.type === "VariableDeclaration") {
 		for (const declaration of node.declarations ?? []) collectBindingNames(declaration.id, names);
@@ -348,40 +357,49 @@ function appendGlobalBindingPublish(source: string, names: readonly string[]): s
  *   let { a, b } = obj;      -> var { a, b } = obj;
  *   class Foo extends Bar {} -> var Foo = class extends Bar {};
  *
- * When the source must run inside the async wrapper, demoted `var`s would normally become
- * function-scoped. In that mode we publish each top-level binding back to the wrapper's
- * lexical `this`, which is the worker global object.
+ * When the source must run inside the async wrapper (top-level `await`), demoted `var`s —
+ * and the user's own top-level `var` and `function` declarations — would be scoped to the
+ * wrapper function and die with the cell. In that mode we publish every top-level binding
+ * back to the wrapper's lexical `this`, which is the worker global object.
  *
- * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
+ * Nested declarations (inside functions, blocks, classes) are left alone — they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
 async function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): Promise<string> {
-	if (!/\b(?:const|let|class)\b/.test(code)) return code;
+	const publishGlobals = options.publishGlobals === true;
+	const fastPath = publishGlobals ? /\b(?:const|let|class|var|function)\b/ : /\b(?:const|let|class)\b/;
+	if (!fastPath.test(code)) return code;
 
 	const ast = await parseProgram(code);
 	if (!ast) {
 		return code;
 	}
 
-	const targets: BabelLexicalDecl[] = [];
+	const targets: Array<{ node: BabelPublishableDecl; demote: boolean }> = [];
 	for (const node of ast.program.body) {
 		if (node.type === "VariableDeclaration") {
 			const decl = node as unknown as BabelVariableDeclaration;
-			if (decl.kind === "const" || decl.kind === "let") targets.push(decl);
+			if (decl.kind === "const" || decl.kind === "let") targets.push({ node: decl, demote: true });
+			else if (publishGlobals) targets.push({ node: decl, demote: false });
 		} else if (node.type === "ClassDeclaration") {
 			const decl = node as unknown as BabelClassDeclaration;
-			if (decl.id) targets.push(decl);
+			if (decl.id) targets.push({ node: decl, demote: true });
+		} else if (publishGlobals && node.type === "FunctionDeclaration") {
+			const decl = node as unknown as BabelFunctionDeclaration;
+			if (decl.id) targets.push({ node: decl, demote: false });
 		}
 	}
 	if (targets.length === 0) return code;
 
-	targets.sort((a, b) => b.start - a.start);
+	targets.sort((a, b) => b.node.start - a.node.start);
 	let result = code;
-	for (const node of targets) {
+	for (const { node, demote } of targets) {
 		const segment = result.slice(node.start, node.end);
-		const bindingNames = options.publishGlobals ? getLexicalBindingNames(node) : [];
+		const bindingNames = publishGlobals ? getLexicalBindingNames(node) : [];
 		let replacement: string;
-		if (node.type === "VariableDeclaration") {
+		if (!demote) {
+			replacement = segment;
+		} else if (node.type === "VariableDeclaration") {
 			replacement = `var${segment.slice(node.kind.length)}`;
 		} else {
 			const id = node.id;

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

@@ -15,6 +15,7 @@ export interface PyToolBridgeEntry {
 	toolSession: ToolSession;
 	signal?: AbortSignal;
 	emitStatus?: (event: JsStatusEvent) => void;
+	abortRequested?: () => boolean;
 }
 
 export interface PyToolBridgeInfo {
@@ -31,23 +32,21 @@ 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.
+ * Forward a bridge call to {@link callSessionTool} while respecting eval abort
+ * shielding.
  *
- * 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.
+ * Python invokes this bridge with blocking `urllib` requests from worker threads
+ * (each `agent()` / `tool.*` call). The base executor defers the registered
+ * signal while a bridge call is already paused so in-flight subagents can finish
+ * and persist output instead of being orphaned. Once an abort has been requested,
+ * later bridge calls are rejected before starting; once the shielded signal
+ * finally aborts, this handler still resolves the HTTP request promptly so the
+ * kernel can unwind without being hard-killed.
  */
 async function callSessionToolPromptOnAbort(name: string, args: unknown, entry: PyToolBridgeEntry): Promise<unknown> {
+	if (entry.abortRequested?.()) {
+		throw new Error(`bridge call ${JSON.stringify(name)} aborted: eval cell was interrupted`);
+	}
 	const call = callSessionTool(name, args, {
 		session: entry.toolSession,
 		signal: entry.signal,

package/src/exec/non-interactive-env.ts

@@ -15,7 +15,6 @@ export const NON_INTERACTIVE_ENV: Readonly<Record<string, string>> = {
 	LESS: "FRX",
 	// Disable terminal features that can block the process.
 	TERM: "dumb",
-	GPG_TTY: "not a tty",
 	NO_COLOR: "1",
 	PYTHONUNBUFFERED: "1",
 	// Disable editor and terminal credential prompts.

package/src/export/ttsr.ts

@@ -447,9 +447,6 @@ export class TtsrManager {
 				strictness: AstMatchStrictness.Smart,
 				limit: 1,
 			});
-			if (result.parseErrors && result.parseErrors.length > 0) {
-				logger.debug("TTSR ast match reported parse errors", { parseErrors: result.parseErrors });
-			}
 			return result.totalMatches > 0;
 		} catch (error) {
 			logger.warn("TTSR ast match failed, treating as no match", {