@oh-my-pi/pi-coding-agent 17.2.1 → 17.2.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.1",
+	"version": "17.2.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.2.1",
-		"@oh-my-pi/omp-stats": "17.2.1",
-		"@oh-my-pi/pi-agent-core": "17.2.1",
-		"@oh-my-pi/pi-ai": "17.2.1",
-		"@oh-my-pi/pi-catalog": "17.2.1",
-		"@oh-my-pi/pi-mnemopi": "17.2.1",
-		"@oh-my-pi/pi-natives": "17.2.1",
-		"@oh-my-pi/pi-tui": "17.2.1",
-		"@oh-my-pi/pi-utils": "17.2.1",
-		"@oh-my-pi/pi-wire": "17.2.1",
-		"@oh-my-pi/snapcompact": "17.2.1",
+		"@oh-my-pi/hashline": "17.2.2",
+		"@oh-my-pi/omp-stats": "17.2.2",
+		"@oh-my-pi/pi-agent-core": "17.2.2",
+		"@oh-my-pi/pi-ai": "17.2.2",
+		"@oh-my-pi/pi-catalog": "17.2.2",
+		"@oh-my-pi/pi-mnemopi": "17.2.2",
+		"@oh-my-pi/pi-natives": "17.2.2",
+		"@oh-my-pi/pi-tui": "17.2.2",
+		"@oh-my-pi/pi-utils": "17.2.2",
+		"@oh-my-pi/pi-wire": "17.2.2",
+		"@oh-my-pi/snapcompact": "17.2.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/commit/agentic/index.ts

@@ -9,7 +9,7 @@ import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-select
 import type { CommitCommandArgs, ConventionalAnalysis, NumstatEntry } from "../../commit/types";
 import { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
-import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
+import { discoverAuthStorage, discoverContextFiles, loadCliExtensionProviders } from "../../sdk";
 import * as git from "../../utils/git";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
@@ -32,6 +32,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	process.stdout.write("● Resolving model...\n");
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	await loadCliExtensionProviders(modelRegistry, settings, cwd);
 	const stagedFilesPromise = (async () => {
 		let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		if (stagedFiles.length === 0) {

package/src/commit/pipeline.ts

@@ -4,7 +4,7 @@ import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import { getProjectDir, logger, prompt } from "@oh-my-pi/pi-utils";
 import { ModelRegistry } from "../config/model-registry";
 import { Settings } from "../config/settings";
-import { discoverAuthStorage } from "../sdk";
+import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
 import { loadProjectContextFiles } from "../system-prompt";
 import * as git from "../utils/git";
 import { runAgenticCommit } from "./agentic";
@@ -40,11 +40,12 @@ export async function runCommitCommand(args: CommitCommandArgs): Promise<void> {
 
 async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 	const cwd = getProjectDir();
-	const settings = await Settings.init();
+	const settings = await Settings.init({ cwd });
 	const commitSettings = settings.getGroup("commit");
 	const authStorage = await discoverAuthStorage();
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	await loadCliExtensionProviders(modelRegistry, settings, cwd);
 
 	const {
 		model: primaryModel,

package/src/config/keybindings.ts

@@ -53,6 +53,7 @@ interface AppKeybindings {
 	"app.plan.toggle": true;
 	"app.history.search": true;
 	"app.stt.toggle": true;
+	"app.live.toggle": true;
 }
 
 export type AppKeybinding = keyof AppKeybindings;
@@ -92,7 +93,7 @@ export const KEYBINDINGS = {
 		description: "Suspend application",
 	},
 	"app.display.reset": {
-		defaultKeys: "ctrl+l",
+		defaultKeys: "alt+l",
 		description: "Reset terminal display",
 	},
 	"app.thinking.cycle": {
@@ -222,6 +223,10 @@ export const KEYBINDINGS = {
 		defaultKeys: [],
 		description: "Toggle speech-to-text (default gesture: hold Space)",
 	},
+	"app.live.toggle": {
+		defaultKeys: "ctrl+l",
+		description: "Start or stop live voice mode (/live)",
+	},
 } as const satisfies KeybindingDefinitions;
 
 /**

package/src/config/settings-schema.ts

@@ -5289,7 +5289,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Services",
 			label: "Codex Auto-Redeem Saved Resets",
 			description:
-				"When a turn is blocked by the Codex weekly limit on the active account and no other account is available, run the conservative saved-reset check. unset asks before spending the first eligible reset, yes spends eligible resets without prompting, and no disables the check entirely. Requires retries enabled.",
+				"Spend saved Codex rate-limit resets automatically: restore an account blocked by an exhausted 5h or weekly window when a turn is stuck and no other account can take over, and salvage credits that are about to expire. unset asks before the first spend, yes spends without prompting, and no disables both checks.",
 			options: [
 				{
 					value: "unset",
@@ -5309,7 +5309,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Services",
 			label: "Codex Auto-Redeem Min Block",
 			description:
-				"Only auto-redeem when the natural weekly reset is at least this many minutes away (don't spend a ~30-day credit to save a short wait).",
+				"Only auto-redeem when the natural unblock — the latest reset among the exhausted 5h/weekly windows — is at least this many minutes away (don't spend a scarce credit to save a short wait). Raise it (e.g. 360) to ignore 5h-only blocks.",
 		},
 	},
 	"codexResets.keepCredits": {
@@ -5319,7 +5319,19 @@ export const SETTINGS_SCHEMA = {
 			tab: "providers",
 			group: "Services",
 			label: "Codex Auto-Redeem Reserve",
-			description: "Never auto-spend below this many saved resets (0 = the last credit may be spent automatically).",
+			description:
+				"Never auto-spend below this many saved resets (0 = the last credit may be spent automatically). Credits about to expire are exempt — a reserved credit that expires preserves nothing.",
+		},
+	},
+	"codexResets.salvageHorizonHours": {
+		type: "number",
+		default: 12,
+		ui: {
+			tab: "providers",
+			group: "Services",
+			label: "Codex Reset Salvage Horizon",
+			description:
+				"Spend a saved Codex reset automatically when it would otherwise expire within this many hours and either chat window (5h or weekly) has meaningful usage to restore (0 disables expiry salvage).",
 		},
 	},
 	"provider.appendOnlyContext": {
@@ -5784,6 +5796,7 @@ export interface CodexResetsSettings {
 	autoRedeem: CodexAutoRedeemMode;
 	minBlockedMinutes: number;
 	keepCredits: number;
+	salvageHorizonHours: number;
 }
 
 export interface GcSettings {

package/src/edit/hashline/block-resolver.ts

@@ -1,9 +1,9 @@
 /**
- * Tree-sitter-backed {@link BlockResolver} for the hashline block replace
- * operator. Bridges the pure hashline seam to the native `blockRangeAt`
- * primitive in `@oh-my-pi/pi-natives`, which infers the language from the file
- * path and returns the 1-indexed line span of the syntactic block beginning on
- * the requested line (or `null` when none can be resolved).
+ * Tree-sitter-backed {@link BlockResolver} for the hashline `N*` locator.
+ * Bridges the pure hashline seam to the native `blockRangeAt` primitive in
+ * `@oh-my-pi/pi-natives`, which infers the language from the file path and
+ * returns the 1-indexed line span of the syntactic block beginning on the
+ * requested line (or `null` when none can be resolved).
  */
 import type { BlockResolver } from "@oh-my-pi/hashline";
 import { blockRangeAt } from "@oh-my-pi/pi-natives";

package/src/edit/hashline/diff.ts

@@ -17,6 +17,7 @@ import {
 	type Cursor,
 	computeFileHash,
 	type Edit,
+	forkClipboard,
 	Patch as HashlinePatch,
 	hasBlockEdit,
 	MismatchError,
@@ -53,10 +54,10 @@ export interface HashlineDiffOptions {
 	skipHashValidation?: boolean;
 	/**
 	 * Clipboard register shared across the sections of one patch preview.
-	 * `CUT` in an earlier section feeds `PASTE` in a later one, so the preview
-	 * matches apply. Multi-section previews MUST thread one register through
-	 * sections in patch order; omitted, each section gets a
-	 * private register (same-file cut/paste still previews correctly).
+	 * `CUT` in an earlier section feeds a register-backed `PUT` in a later one,
+	 * so the preview matches apply. Multi-section previews MUST thread one
+	 * register through sections in patch order; omitted, each section gets a
+	 * private register (same-file cut/put still previews correctly).
 	 */
 	clipboard?: Clipboard;
 }
@@ -153,9 +154,11 @@ async function readSectionForPreview(
 
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
-		if (edit.kind === "delete") return true;
-		if (edit.kind === "block") return true;
-		if (edit.kind === "cut") return true;
+		if (edit.kind === "delete" || edit.kind === "block" || edit.kind === "cut") return true;
+		if (edit.kind === "paste") {
+			if (edit.at.kind === "span") return true;
+			return edit.at.cursor.kind === "before_anchor" || edit.at.cursor.kind === "after_anchor";
+		}
 		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
 	});
 }
@@ -279,19 +282,23 @@ function buildStreamingSectionDiff(
 		onUnresolved: "drop",
 	});
 	const fileLines = normalized.split("\n");
-	// Expand clipboard ops so a `PASTE` previews the moved rows. Resolve into
-	// a scratch register and commit it back only on success: a mid-typed
-	// capture (out-of-range while the range digits are still streaming,
-	// transient sequencing violations) throws AFTER earlier captures may have
-	// landed, and leaking those into the shared register would let a later
-	// section preview a paste that never happened. On failure, fall back to
-	// filtering the clipboard edits out of this section's frame.
-	const scratch: Clipboard = { ...clipboard };
+	// Expand register-backed PUT ops so moved rows appear in the preview.
+	// Resolve into a transactional register and publish it only on success: a
+	// mid-typed capture (out-of-range while the range digits are still
+	// streaming, transient sequencing violations) throws AFTER earlier
+	// captures may have landed, and leaking those into the shared register
+	// would let a later section preview a PUT that never happened. On failure,
+	// filter the clipboard edits out of this section's frame.
+	const scratch = forkClipboard(clipboard);
 	let resolved: readonly Edit[];
 	try {
 		resolved = resolveClipboardEdits(blockResolved, fileLines, scratch, { onEmptyPaste: "drop" });
 		if (scratch.lines === undefined) delete clipboard.lines;
 		else clipboard.lines = scratch.lines;
+		if (scratch.named === undefined) delete clipboard.named;
+		else clipboard.named = scratch.named;
+		if (scratch.pendingAnonCuts === undefined) delete clipboard.pendingAnonCuts;
+		else clipboard.pendingAnonCuts = scratch.pendingAnonCuts;
 	} catch {
 		resolved = blockResolved.filter(edit => edit.kind !== "cut" && edit.kind !== "paste");
 	}

package/src/edit/hashline/execute.ts

@@ -21,6 +21,7 @@ import {
 	Patcher,
 	type PatchSectionResult,
 	type PreparedSection,
+	startClipboardBatch,
 } from "@oh-my-pi/hashline";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
@@ -48,7 +49,7 @@ export interface ExecuteHashlineSingleOptions {
 
 function noChangeDiagnostic(path: string): string {
 	// The patch parsed and applied cleanly but produced no change — the
-	// `|literal` body rows matched the file content at the targeted lines
+	// `+TEXT` body rows matched the file content at the targeted lines
 	// byte-for-byte. The model usually misreads this as "wrong anchor, try
 	// again with a bigger payload" and starts duplicating content; the
 	// message below names the cause directly so the next turn can re-read
@@ -103,14 +104,14 @@ interface RenderedSection {
 }
 
 const BLOCK_OP_LABELS: Record<BlockResolution["op"], string> = {
-	replace: "SWAP.BLK",
-	insert_after: "INS.BLK.POST",
-	cut: "CUT.BLK",
-	paste_after: "PASTE.BLK.POST",
+	replace: "PUT N*:",
+	insert_after: "PUT >N*:",
+	cut: "CUT N*",
+	paste_after: "PUT >N*",
 };
 
 function formatBlockResolution(resolution: BlockResolution): string {
-	const op = BLOCK_OP_LABELS[resolution.op];
+	const op = BLOCK_OP_LABELS[resolution.op].replace("N", String(resolution.anchorLine));
 	const lines = resolution.end - resolution.start + 1;
 	const span =
 		resolution.start === resolution.end ? `line ${resolution.start}` : `lines ${resolution.start}-${resolution.end}`;
@@ -120,7 +121,7 @@ function formatBlockResolution(resolution: BlockResolution): string {
 			: resolution.op === "paste_after"
 				? `; clipboard lands after line ${resolution.end}`
 				: "";
-	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
+	return `${op} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
 }
 
 function renderSection(
@@ -229,11 +230,11 @@ export async function executeHashlineSingle(
 	const enforceSeenLines = options.session.settings.get("edit.enforceSeenLines");
 	const patcher = new Patcher({ fs, snapshots, blockResolver: nativeBlockResolver, enforceSeenLines });
 
-	// The clipboard register is session-persistent: `CUT` in one edit call can
-	// `PASTE` in a later one. Each batch works on a fork and publishes it back
-	// only after writes land.
+	// Named registers persist across edit calls; the anonymous register is
+	// batch-local. Each batch starts without anonymous state and publishes
+	// named registers only after writes land.
 	const sessionClipboard = getEditClipboard(options.session);
-	const clipboard = forkClipboard(sessionClipboard);
+	const clipboard = startClipboardBatch(sessionClipboard);
 
 	// Single-section fast path: prepare, commit, render.
 	const inputHash = hashPatchInput(options.input);
@@ -254,8 +255,8 @@ export async function executeHashlineSingle(
 	}
 
 	// Multi-section: prepare every section up front so we fail fast before
-	// any write hits the filesystem. One clipboard register spans the batch,
-	// so `CUT` in one section feeds `PASTE` in a later one.
+	// any write hits the filesystem. One batch-local register spans the batch,
+	// so `CUT` in one section feeds a register-backed `PUT` in a later one.
 	const prepared: PreparedSection[] = [];
 	// Register state after each section's prepare. Commits are non-atomic: a
 	// mid-batch write failure leaves earlier sections on disk, so the session

package/src/edit/renderer.ts

@@ -140,7 +140,7 @@ interface HashlineInputEntry {
 	path: string;
 	op?: Operation;
 	rename?: string;
-	/** A SWAP/CUT/INS line-editing op precedes the file op — keeps a move framed. */
+	/** A PUT/CUT line edit precedes the file op — keeps a move framed. */
 	hasLineEdits?: boolean;
 }
 
@@ -568,9 +568,9 @@ function parseHashlineInputPreviewHeader(line: string): string | null {
 	return previewPath.length > 0 ? previewPath : null;
 }
 
-// Line-editing op headers (SWAP/CUT/INS family), distinct from file-level
+// Line-editing op headers (PUT/CUT family), distinct from file-level
 // REM/MV ops. Body rows are `+TEXT`, so this only matches real headers.
-const HL_LINE_OP_HEADER = /^(?:SWAP|CUT|INS)\b/;
+const HL_LINE_OP_HEADER = /^(?:PUT|CUT)\b/;
 
 /**
  * Walk a (possibly mid-stream) hashline payload into per-section descriptors:

package/src/eval/executor-base.ts

@@ -313,6 +313,45 @@ export function attachSessionOwner(
 	}
 }
 
+/** Owner registry shared by every language's live/starting session records. */
+export interface SessionOwners {
+	ownerIds: Set<string>;
+	hasFallbackOwner: boolean;
+}
+
+/**
+ * Resolve the session key an owner's eval cell runs on, forking `reset` away
+ * from shared kernels.
+ *
+ * Eval sessions are shared across agents by design (subagents inherit the
+ * parent's eval session id), so honoring `reset` on a co-owned kernel would
+ * destroy every other agent's state — including cells executing at that
+ * moment. When the requester does not exclusively own the live base session,
+ * its reset resolves to a deterministic per-owner fork key: the requester
+ * starts a fresh private kernel while co-owners keep the shared one. Once
+ * forked, the owner keeps resolving to its fork, and per-owner dispose reaps
+ * the fork since the requester is its only registered owner.
+ */
+export function resolveOwnerScopedSessionKey(options: {
+	baseKey: string;
+	ownerId: string | undefined;
+	reset: boolean;
+	/** True when a live or starting session exists under `key`. */
+	hasSession: (key: string) => boolean;
+	/** Owner registry for the session under `key`, when inspectable. */
+	getOwners: (key: string) => SessionOwners | undefined;
+}): string {
+	const { baseKey, ownerId } = options;
+	if (ownerId === undefined) return baseKey;
+	const forkKey = `${baseKey}\0fork\0${ownerId}`;
+	if (options.hasSession(forkKey)) return forkKey;
+	if (!options.reset) return baseKey;
+	const base = options.getOwners(baseKey);
+	if (!base) return baseKey;
+	const exclusive = !base.hasFallbackOwner && base.ownerIds.size === 1 && base.ownerIds.has(ownerId);
+	return exclusive ? baseKey : forkKey;
+}
+
 // ---------------------------------------------------------------------------
 // Base executor implementation
 // ---------------------------------------------------------------------------

package/src/eval/jl/executor.ts

@@ -1,7 +1,12 @@
 import * as path from "node:path";
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from "../../tools";
-import { attachSessionOwner, createCancelledKernelResult, executeWithKernelBase } from "../executor-base";
+import {
+	attachSessionOwner,
+	createCancelledKernelResult,
+	executeWithKernelBase,
+	resolveOwnerScopedSessionKey,
+} from "../executor-base";
 import { ensurePyToolBridge, type PyToolBridgeInfo } from "../py/tool-bridge";
 import type { EvalDisplayOutput, EvalStatusEvent } from "../types";
 import {
@@ -451,7 +456,13 @@ async function ensureToolBridge(options: JuliaExecutorOptions): Promise<void> {
 
 async function executeOnSession(code: string, cwd: string, options: JuliaExecutorOptions): Promise<JuliaResult> {
 	const sessionId = options.sessionId ?? `session:${cwd}`;
-	const sessionKey = buildSessionKey(sessionId, cwd, options.interpreter);
+	const sessionKey = resolveOwnerScopedSessionKey({
+		baseKey: buildSessionKey(sessionId, cwd, options.interpreter),
+		ownerId: options.kernelOwnerId,
+		reset: options.reset === true,
+		hasSession: key => sessions.has(key) || startingSessions.has(key),
+		getOwners: key => sessions.get(key) ?? startingSessions.get(key),
+	});
 	if (options.bridge && !options.bridgeSessionId) {
 		options.bridgeSessionId = sessionId;
 	}

package/src/eval/js/context-manager.ts

@@ -8,6 +8,7 @@ import {
 import type { ToolSession } from "../../tools";
 import { ToolAbortError, ToolError } from "../../tools/tool-errors";
 import { safeSend as safeSendIpc } from "../../utils/ipc";
+import { attachSessionOwner, resolveOwnerScopedSessionKey, type SessionOwners } from "../executor-base";
 import { shouldDetachKernel } from "../py/spawn-options";
 import { callSessionTool, type JsStatusEvent } from "./tool-bridge";
 import { WorkerCore } from "./worker-core";
@@ -57,10 +58,16 @@ interface JsSession {
 	worker: WorkerHandle;
 	state: "alive" | "dead";
 	pending: Map<string, PendingRun>;
+	ownerIds: Set<string>;
+	hasFallbackOwner: boolean;
+}
+
+interface StartingJsSession extends SessionOwners {
+	promise: Promise<JsSession>;
 }
 
 const sessions = new Map<string, JsSession>();
-const startingSessions = new Map<string, Promise<JsSession>>();
+const startingSessions = new Map<string, StartingJsSession>();
 const resettingSessions = new Map<string, Promise<void>>();
 // Worker startup (module-graph import + WorkerCore construction) is infrastructure
 // cost, not user compute. Floor it independently of Bun's 5s default per-test timeout
@@ -99,6 +106,8 @@ export function setJsEvalWorkerThreadForTests(enabled: boolean): boolean {
 export async function executeInVmContext(options: {
 	sessionKey: string;
 	sessionId: string;
+	/** Logical owner identifier; scopes `reset` on shared contexts and retained-worker cleanup. */
+	ownerId?: string;
 	cwd: string;
 	session: ToolSession;
 	localRoots?: Record<string, string>;
@@ -108,47 +117,55 @@ export async function executeInVmContext(options: {
 	timeoutMs?: number;
 	runState: VmRunState;
 }): Promise<{ value: unknown }> {
+	const sessionKey = resolveOwnerScopedSessionKey({
+		baseKey: options.sessionKey,
+		ownerId: options.ownerId,
+		reset: options.reset === true,
+		hasSession: key => sessions.has(key) || startingSessions.has(key),
+		getOwners: key => sessions.get(key) ?? startingSessions.get(key),
+	});
 	if (options.reset) {
 		// Coalesce concurrent resets: an existing in-flight reset already
 		// produces a fresh context, so a follow-up `reset: true` cell should
 		// just wait for it rather than failing the user-visible call.
-		const inFlight = resettingSessions.get(options.sessionKey);
+		const inFlight = resettingSessions.get(sessionKey);
 		if (inFlight) await inFlight.catch(() => undefined);
 		else {
-			const resetPromise = resetVmContext(options.sessionKey);
+			const resetPromise = resetVmContext(sessionKey);
 			resettingSessions.set(
-				options.sessionKey,
+				sessionKey,
 				resetPromise.then(() => undefined),
 			);
 			try {
 				await resetPromise;
 			} finally {
-				resettingSessions.delete(options.sessionKey);
+				resettingSessions.delete(sessionKey);
 			}
 		}
 	} else {
 		// Internal coordination: wait for any in-flight reset to settle and
 		// then run on the freshly-rebuilt context.
-		const inFlight = resettingSessions.get(options.sessionKey);
+		const inFlight = resettingSessions.get(sessionKey);
 		if (inFlight) await inFlight.catch(() => undefined);
 	}
 	const session = await acquireSession(
-		options.sessionKey,
+		sessionKey,
 		{ cwd: options.cwd, sessionId: options.sessionId, localRoots: options.localRoots },
 		options.timeoutMs,
+		options.ownerId,
 	);
 	return await runOnce(session, options);
 }
 
 export async function resetVmContext(sessionKey: string): Promise<void> {
-	const session = sessions.get(sessionKey) ?? (await startingSessions.get(sessionKey)?.catch(() => undefined));
+	const session = sessions.get(sessionKey) ?? (await startingSessions.get(sessionKey)?.promise.catch(() => undefined));
 	if (!session) return;
 	sessions.delete(sessionKey);
 	await killSession(session, new ToolError("JS context reset"), { force: false });
 }
 
 export async function disposeAllVmContexts(): Promise<void> {
-	const pending = [...startingSessions.values()];
+	const pending = [...startingSessions.values()].map(starting => starting.promise);
 	startingSessions.clear();
 	const started = await Promise.allSettled(pending);
 	const all = [...sessions.values()];
@@ -160,6 +177,45 @@ export async function disposeAllVmContexts(): Promise<void> {
 	await Promise.all(all.map(session => killSession(session, new ToolError("JS context disposed"), { force: false })));
 }
 
+/**
+ * Shut down retained JS contexts owned solely by `ownerId` (e.g. a subagent's
+ * private fork); shared contexts just drop the owner registration.
+ */
+export async function disposeVmContextsByOwner(ownerId: string): Promise<void> {
+	const toKill: JsSession[] = [];
+	for (const session of [...sessions.values()]) {
+		if (!session.ownerIds.has(ownerId)) continue;
+		if (session.ownerIds.size === 1) {
+			toKill.push(session);
+			continue;
+		}
+		session.ownerIds.delete(ownerId);
+	}
+	const startingToKill: StartingJsSession[] = [];
+	for (const [sessionKey, starting] of [...startingSessions.entries()]) {
+		if (sessions.has(sessionKey) || !starting.ownerIds.has(ownerId)) continue;
+		if (starting.ownerIds.size === 1) {
+			startingSessions.delete(sessionKey);
+			startingToKill.push(starting);
+			continue;
+		}
+		starting.ownerIds.delete(ownerId);
+	}
+	for (const session of toKill) {
+		if (sessions.get(session.sessionKey) === session) sessions.delete(session.sessionKey);
+	}
+	const started = await Promise.allSettled(startingToKill.map(starting => starting.promise));
+	for (const result of started) {
+		if (result.status !== "fulfilled") continue;
+		const session = result.value;
+		if (sessions.get(session.sessionKey) === session) sessions.delete(session.sessionKey);
+		toKill.push(session);
+	}
+	await Promise.all(
+		toKill.map(session => killSession(session, new ToolError("JS context disposed"), { force: false })),
+	);
+}
+
 /**
  * Smoke probe: spawn the JS evaluator through the worker-host entry and prove
  * it answers the `init` handshake in a real isolated subprocess (not the inline
@@ -177,6 +233,8 @@ export async function smokeTestJsEvalWorker(): Promise<void> {
 		worker,
 		state: "alive",
 		pending: new Map(),
+		ownerIds: new Set(),
+		hasFallbackOwner: false,
 	};
 	try {
 		await initWorker(session, { cwd: process.cwd(), sessionId: "smoke" }, WORKER_INIT_TIMEOUT_MS);
@@ -243,15 +301,25 @@ async function runOnce(
 	}
 }
 
-async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, timeoutMs?: number): Promise<JsSession> {
+async function acquireSession(
+	sessionKey: string,
+	snapshot: SessionSnapshot,
+	timeoutMs?: number,
+	ownerId?: string,
+): Promise<JsSession> {
 	const existing = sessions.get(sessionKey);
 	if (existing && existing.state === "alive") {
 		existing.sessionId = snapshot.sessionId;
 		existing.cwd = snapshot.cwd;
+		attachSessionOwner(existing, snapshot.sessionId, ownerId);
 		return existing;
 	}
 	const starting = startingSessions.get(sessionKey);
-	if (starting) return await starting;
+	if (starting) {
+		attachSessionOwner(starting, snapshot.sessionId, ownerId);
+		return await starting.promise;
+	}
+	let startingSession!: StartingJsSession;
 
 	const startup = (async (): Promise<JsSession> => {
 		// Attach the message listener before sending init. Both Bun Worker messages
@@ -264,6 +332,8 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, tim
 			worker,
 			state: "alive",
 			pending: new Map(),
+			ownerIds: new Set(),
+			hasFallbackOwner: false,
 		};
 		// Init headroom is the fixed infrastructure floor; the caller's per-cell timeout
 		// dominates when larger so users can grant more by raising `timeout` on a cell.
@@ -293,14 +363,27 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, tim
 				session.state = "alive";
 			}
 		}
-		sessions.set(sessionKey, session);
+		session.ownerIds = new Set(startingSession.ownerIds);
+		session.hasFallbackOwner = startingSession.hasFallbackOwner;
+		// Publish only while this startup still owns the key: owner disposal or
+		// a concurrent dispose-all may have already reaped the starting record,
+		// and publishing here would resurrect a context that was just torn down.
+		if (startingSessions.get(sessionKey) === startingSession) {
+			sessions.set(sessionKey, session);
+		}
 		return session;
 	})();
-	startingSessions.set(sessionKey, startup);
+	startingSession = {
+		ownerIds: new Set(),
+		hasFallbackOwner: false,
+		promise: startup,
+	};
+	attachSessionOwner(startingSession, snapshot.sessionId, ownerId);
+	startingSessions.set(sessionKey, startingSession);
 	try {
 		return await startup;
 	} finally {
-		if (startingSessions.get(sessionKey) === startup) startingSessions.delete(sessionKey);
+		if (startingSessions.get(sessionKey) === startingSession) startingSessions.delete(sessionKey);
 	}
 }
 

package/src/eval/js/executor.ts

@@ -19,6 +19,8 @@ export interface JsExecutorOptions {
 	onStatus?: (event: JsStatusEvent) => void;
 	signal?: AbortSignal;
 	sessionId: string;
+	/** Logical owner identifier; scopes `reset` on shared contexts and retained-worker cleanup. */
+	kernelOwnerId?: string;
 	reset?: boolean;
 	sessionFile?: string;
 	artifactPath?: string;
@@ -100,6 +102,7 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 		await executeInVmContext({
 			sessionKey: options.sessionId,
 			sessionId: options.sessionId,
+			ownerId: options.kernelOwnerId,
 			cwd: options.cwd ?? options.session.cwd,
 			session: options.session,
 			localRoots: options.localRoots,

package/src/eval/js/index.ts

@@ -28,6 +28,7 @@ export default {
 			idleTimeoutMs: opts.idleTimeoutMs,
 			signal: opts.signal,
 			sessionId: namespaceSessionId(opts.sessionId),
+			kernelOwnerId: opts.kernelOwnerId,
 			sessionFile: opts.sessionFile,
 			reset: opts.reset,
 			onChunk: opts.onChunk,