@code-yeongyu/senpi 2026.9.21-2 → 2026.9.22-2

package/node_modules/@code-yeongyu/senpi-codemode/README.md

@@ -93,6 +93,7 @@ Configuration is loaded in this order:
   "foregroundWindowSeconds": 60,
   "runBudgetSeconds": 300,
   "hardLimitSeconds": 1800,
+  "maxDetachedCells": 15,
   "parallelPoolWidth": 4,
   "taskTools": {
     "task": "task",
@@ -110,9 +111,10 @@ Configuration is loaded in this order:
 | --- | --- | --- |
 | `languages` | `py`/`js` enabled; `rb`/`jl` disabled | Selects desired languages before interpreter detection. |
 | `cellTimeoutSeconds` | `30` | Idle time an interactive call blocks the turn before the cell detaches. Print/json calls never detach. |
-| `foregroundWindowSeconds` | `60` | Caps `cellTimeoutSeconds` and the grace a bridge-parked cell gets before it detaches, so an interactive call never blocks the turn longer than this. Env override: `SENPI_CODEMODE_FOREGROUND_SECONDS`. |
-| `runBudgetSeconds` | `300` | Kill deadline for a cell's own execution time - child processes, network, timers, CPU. Time parked in host tool calls (`agent()`, `tool.*`) is not charged, and the budget keeps counting after the cell detaches. A per-call `timeout` replaces it for that cell. Env override: `SENPI_CODEMODE_RUN_BUDGET_SECONDS`. |
-| `hardLimitSeconds` | `1800` | Wall-clock kill deadline for a cell, parked or not; a per-call `timeout` above it raises it. Env override: `SENPI_CODEMODE_HARD_LIMIT_SECONDS`. |
+| `foregroundWindowSeconds` | `60` | Submission-based foreground limit, including queue and bridge pauses. The cell detaches if capacity is available; otherwise it is cancelled with `eval_background_capacity_reached`. Env override: `SENPI_CODEMODE_FOREGROUND_SECONDS`. |
+| `runBudgetSeconds` | `300` | Kill deadline for a cell's own execution time - child processes, network, timers, CPU. Time queued or parked in host tool calls (`agent()`, `tool.*`) is not charged, and the budget keeps counting after the cell detaches. A per-call `timeout` replaces it for that cell. Env override: `SENPI_CODEMODE_RUN_BUDGET_SECONDS`. |
+| `hardLimitSeconds` | `1800` | Wall-clock kill deadline from submission, including queue and parked time; a per-call `timeout` above it raises it. Env override: `SENPI_CODEMODE_HARD_LIMIT_SECONDS`. |
+| `maxDetachedCells` | `15` | Global detached-cell capacity across all kernels, including queued cells. At capacity, interactive cells stay foreground until completion or the foreground window elapses. Env override: `SENPI_CODEMODE_MAX_DETACHED_CELLS`. |
 | `parallelPoolWidth` | `4` | Maximum concurrent `parallel()` thunks. |
 | `taskTools.task` | `"task"` | Registered tool name used by `agent()`. |
 | `taskTools.output` | `"task_output"` | Registered tool name used by `output()`. |
@@ -126,6 +128,9 @@ enables; `0` or `false` disables. Any other value leaves the file setting in
 effect.
 
 Malformed JSON or invalid settings fall back to defaults with a warning.
+The detached-cell environment override uses the run-budget parser: a positive
+base-10 integer wins over the file value; zero, negative, and malformed values
+leave the file value in effect.
 
 ## Cell helpers
 
@@ -162,13 +167,25 @@ tasks return the requested transcript. Missing tools produce a clear
 availability error instead of importing an orchestration package. `agent()`
 delegates through the tool contract, so task-engine permissions, progress
 updates, and transcripts remain owned by that engine.
-`isolated`, `apply`, and `merge` are accepted for compatibility but emit a
-warning because this task-engine integration has no isolation model.
+`isolated` and `apply` accept booleans; `merge` accepts `"patch"` or `"branch"`
+(and `false`/`true` aliases respectively). The bridge checks the configured task
+parameter schema once per bridge, using the same host catalog as `tool_schema()`.
+If it advertises `isolated`, these options are forwarded; otherwise they are
+omitted with the existing warning. Senpi does not implement isolation itself.
+A foreground host result with `details.isolation.changes_applied === false`
+raises `AgentIsolationNotAppliedError` (`isolation_not_applied`), including any
+`patch_path`, `branch_name`, and `manual_command` recovery fields in its message.
+The bridge retains host `details.isolation`; successful foreground helpers still
+return text or parsed JSON.
 
 Background `agent()` handles retain `id` and `agent://<id>` and include `run_epoch`.
 The host must return structured `details.task_id` (`st_` plus lowercase hex) and
 an integer `details.run_epoch >= 0`. Missing or malformed details raise
-`invalid_task_handle`; prose IDs are never used. Foreground text/JSON is unchanged.
+`invalid_task_handle`; prose IDs are never used. Handles return immediately,
+so final isolation results are not available on the initial handle: await the
+completion notification or read `task_output` (via `output()`) after completion.
+Any isolation metadata supplied by the host on a handle is preserved as
+`details.isolation`, not interpreted as a foreground apply failure.
 
 `workpool` takes exactly one of `{category, prompt, model?}` or
 `{subagent_type, prompt, model?}` as its plain-data agent spec. Mode is `fresh`
@@ -203,22 +220,28 @@ without a `summary` fails with a teaching error.
 `eval` accepts `on_timeout: "detach"|"error"`. The default is `"detach"` in
 interactive TUI, RPC, and app-server sessions; print and JSON one-shot runs
 default to `"error"` so their result is never silently detached. A detached
-cell keeps only its own language kernel busy. A new same-language call returns
-a busy error with its cell id and output tail; calls in other languages continue
-normally. Do not re-run the cell.
+cell keeps only its own language kernel busy. New same-language cells are admitted
+into its FIFO queue; calls in other languages continue normally. Queued cells may
+also detach, within the global `maxDetachedCells` cap. At capacity, the first idle
+detach attempt leaves the cell foreground and re-arms one wait for the remaining
+submission-based foreground window. At the window, it detaches if a slot is now
+free; otherwise it settles `cancelled` with `eval_background_capacity_reached`,
+listing the live cells and a stop-or-wait remedy. Cells that complete inside the
+window return normally. Cancelling a queued cell never interrupts its predecessor.
+Do not re-run a detached or queued cell; each detached cell completes as one notification.
 
 Queued steering also detaches an eligible interactive foreground call, including
 one paused in a host tool bridge, without cancelling its computation. If the
-language's detached slot is occupied, steering leaves the call waiting. Follow-up
+global detached cap is reached, steering leaves the call waiting. Follow-up
 messages, explicit `on_timeout: "error"`, and print/JSON calls do not trigger this
 transition; caller abort and existing deadlines retain their cancellation behavior.
 
 Every cell, detached or not, is bounded by two kill deadlines. The run budget
 (`runBudgetSeconds`, or the call's `timeout`) charges only the cell's own
-execution time and is paused while a host tool call is in flight, so a cell
+execution time and is paused while queued or while a host tool call is in flight, so a cell
 waiting on `agent()` survives while a runaway child process or loop does not.
 The hard limit (`hardLimitSeconds`, raised by a larger `timeout`) is wall-clock
-and bounds parked cells too. A cell killed by either deadline reports which one
+from submission and bounds queued and parked cells too. A cell killed by either deadline reports which one
 in its result or completion notification, together with whether kernel state
 survived; the tool schema states the configured numbers. The `timeout` value
 never changes the idle detach deadline: that is `cellTimeoutSeconds` capped by
@@ -227,9 +250,24 @@ never changes the idle detach deadline: that is `cellTimeoutSeconds` capped by
 While any cell is detached, the interactive footer shows a highlighted
 `↗ <language> · <summary>` status on the extension status line (the cell id
 when the call had no summary), clearing as soon as the last detached cell settles.
+Queued entries are labelled `queued`; an all-queued footer shows `(queued)` instead
+of an elapsed duration. Elapsed time counts only from execution start.
+
+Use `eval({ action: "list" })` without a language or cell id to see live and
+recently settled cells across languages. Each line includes the id, language,
+state, elapsed execution seconds, queue predecessors, and summary (or a short code
+preview); `details.cells` carries the typed cell metadata. Listing never consumes
+completion notifications.
+
+A run with `reset: true` resets only its selected language and is refused with
+`eval_kernel_busy_reset_refused` while any other cell in that language is live,
+including queued cells. The requesting cell fails without changing the kernel or
+cancelling existing work. Stop those cells explicitly or wait for their completion
+notifications before resetting; live cells in other languages do not block reset.
 
 Use `eval({ action: "peek", cell_id })` for its state and buffered output, or
-`eval({ action: "stop", cell_id })` to cancel it. Python stop interrupts the
+`eval({ action: "stop", cell_id })` to cancel it. Stopping a queued cell removes it
+without interrupting the active cell; kernel state is retained. Python running-cell stop interrupts the
 existing kernel and preserves variables. JavaScript stop is cooperative first:
 the worker rejects the cell's pending bridge `tool.*` calls and kills the
 `Bun.spawn` children it started, and a cell that settles within the 2 s grace

package/node_modules/@code-yeongyu/senpi-codemode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.21-2",
+	"version": "2026.9.22-2",
 	"private": true,
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
@@ -31,14 +31,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.21-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.22-2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.21-2"
+		"@code-yeongyu/senpi": "2026.9.22-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.21-2"
+		"@code-yeongyu/senpi": "2026.9.22-2"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/agent-bridge.ts

@@ -2,6 +2,7 @@ import type { AgentToolResult } from "@code-yeongyu/senpi";
 import { type Static, Type } from "typebox";
 import { Check, Errors } from "typebox/value";
 import type { EvalStatusEvent, ExecuteTool } from "../tool/types.ts";
+import type { EvalSchemaToolInfo } from "./schema-bridge.ts";
 
 const agentArgsSchema = Type.Object(
 	{
@@ -14,7 +15,7 @@ const agentArgsSchema = Type.Object(
 		tools: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
 		isolated: Type.Optional(Type.Boolean()),
 		apply: Type.Optional(Type.Boolean()),
-		merge: Type.Optional(Type.Boolean()),
+		merge: Type.Optional(Type.Union([Type.Boolean(), Type.Literal("patch"), Type.Literal("branch")])),
 	},
 	{ additionalProperties: false },
 );
@@ -43,6 +44,9 @@ type TaskParams = {
 	readonly name?: string;
 	readonly run_in_background: boolean;
 	readonly tools?: readonly string[];
+	readonly isolated?: boolean;
+	readonly apply?: boolean;
+	readonly merge?: "patch" | "branch";
 };
 type ProgressContext = { readonly fallbackId: string; readonly warning?: string };
 
@@ -54,15 +58,32 @@ export interface RunEvalAgentOptions {
 	readonly callId: string;
 	readonly taskToolName: string;
 	readonly executeTool: AgentExecuteTool;
+	readonly listTools?: () => readonly EvalSchemaToolInfo[];
 	readonly signal?: AbortSignal;
 	readonly emitStatus?: (event: EvalStatusEvent) => void;
 }
 
-export type EvalAgentResult =
+export type EvalAgentResult = (
 	| { readonly text: string }
 	| { readonly text: string; readonly data: unknown }
 	| { readonly text: string; readonly parseError: string }
-	| { readonly text: string; readonly id: string; readonly handle: string; readonly run_epoch: number };
+	| { readonly text: string; readonly id: string; readonly handle: string; readonly run_epoch: number }
+) & { readonly details?: { readonly isolation: Readonly<Record<string, unknown>> } };
+
+// The session-owned executor identifies a bridge across JS and HTTP calls; do not retain retired sessions.
+const isolationCapabilities = new WeakMap<AgentExecuteTool, Map<string, boolean>>();
+
+export class AgentIsolationNotAppliedError extends Error {
+	readonly name = "AgentIsolationNotAppliedError";
+	readonly code = "isolation_not_applied";
+
+	constructor(isolation: Readonly<Record<string, unknown>>) {
+		const recovery = ["patch_path", "branch_name", "manual_command"]
+			.flatMap((key) => (typeof isolation[key] === "string" ? [`${key}: ${isolation[key]}`] : []))
+			.join("; ");
+		super(`agent() isolated changes were not applied${recovery ? `; ${recovery}` : ""}`);
+	}
+}
 
 class AgentArgumentsError extends Error {
 	readonly name = "AgentArgumentsError";
@@ -92,7 +113,8 @@ class AgentHandleError extends Error {
 export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions): Promise<EvalAgentResult> {
 	const parsed = parseAgentArgs(args);
 	const structured = Object.hasOwn(parsed, "schema");
-	const warning = droppedOptionsWarning(parsed);
+	const supportsIsolation = taskSupportsIsolation(options);
+	const warning = supportsIsolation ? undefined : droppedOptionsWarning(parsed);
 	const fallbackId = parsed.label ?? options.callId;
 	if (warning) options.emitStatus?.({ op: "agent", id: fallbackId, status: "running", warning });
 
@@ -104,7 +126,7 @@ export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions):
 
 	let result: AgentToolResult<unknown>;
 	try {
-		result = await options.executeTool(options.taskToolName, toTaskParams(parsed, structured), {
+		result = await options.executeTool(options.taskToolName, toTaskParams(parsed, structured, supportsIsolation), {
 			...(options.signal ? { signal: options.signal } : {}),
 			...(options.emitStatus
 				? {
@@ -119,12 +141,15 @@ export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions):
 	}
 
 	const text = resultText(result);
+	const isolation =
+		isRecord(result.details) && isRecord(result.details.isolation) ? result.details.isolation : undefined;
+	const metadata = isolation === undefined ? {} : { details: { isolation } };
 	if (parsed.handle === true) {
 		const { task_id: id, run_epoch } = resultTaskHandle(result);
-		return { text, id, handle: `agent://${id}`, run_epoch };
+		return { text, id, handle: `agent://${id}`, run_epoch, ...metadata };
 	}
-	if (!structured) return { text };
-	return parseStructuredText(text);
+	if (isolation?.changes_applied === false) throw new AgentIsolationNotAppliedError(isolation);
+	return { ...(structured ? parseStructuredText(text) : { text }), ...metadata };
 }
 
 function parseAgentArgs(value: unknown): AgentArgs {
@@ -135,7 +160,21 @@ function parseAgentArgs(value: unknown): AgentArgs {
 	throw new AgentArgumentsError(summary || "invalid value");
 }
 
-function toTaskParams(args: AgentArgs, structured: boolean): TaskParams {
+function taskSupportsIsolation(options: RunEvalAgentOptions): boolean {
+	let capabilities = isolationCapabilities.get(options.executeTool);
+	if (!capabilities) {
+		capabilities = new Map();
+		isolationCapabilities.set(options.executeTool, capabilities);
+	}
+	const cached = capabilities.get(options.taskToolName);
+	if (cached !== undefined) return cached;
+	const schema = options.listTools?.().find((tool) => tool.name === options.taskToolName)?.parameters;
+	const supported = isRecord(schema) && isRecord(schema.properties) && schema.properties.isolated !== undefined;
+	capabilities.set(options.taskToolName, supported);
+	return supported;
+}
+
+function toTaskParams(args: AgentArgs, structured: boolean, supportsIsolation: boolean): TaskParams {
 	return {
 		prompt: structured
 			? `${args.prompt}\n\nRespond ONLY with JSON matching this JSON-Schema:\n${JSON.stringify(args.schema)}`
@@ -145,6 +184,11 @@ function toTaskParams(args: AgentArgs, structured: boolean): TaskParams {
 		...(args.label === undefined ? {} : { name: args.label }),
 		run_in_background: args.handle === true,
 		...(args.tools === undefined ? {} : { tools: args.tools }),
+		...(supportsIsolation && args.isolated !== undefined ? { isolated: args.isolated } : {}),
+		...(supportsIsolation && args.apply !== undefined ? { apply: args.apply } : {}),
+		...(supportsIsolation && args.merge !== undefined
+			? { merge: args.merge === true ? "branch" : args.merge === false ? "patch" : args.merge }
+			: {}),
 	};
 }
 

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/reserved-dispatch.ts

@@ -35,6 +35,7 @@ export async function runReservedTool(toolName: string, context: ReservedDispatc
 			callId: context.callId,
 			taskToolName: context.taskToolName,
 			executeTool: context.executeTool,
+			...(context.listTools === undefined ? {} : { listTools: context.listTools }),
 			...(context.signal === undefined ? {} : { signal: context.signal }),
 			emitStatus: context.emitStatus,
 		});

package/node_modules/@code-yeongyu/senpi-codemode/src/config/settings.ts

@@ -22,6 +22,7 @@ export const codemodeSettingsSchema = Type.Object(
 		foregroundWindowSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		runBudgetSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		hardLimitSeconds: Type.Optional(Type.Number({ minimum: 1 })),
+		maxDetachedCells: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
 		taskTools: Type.Optional(
 			Type.Object(
@@ -80,6 +81,8 @@ export interface CodemodeSettings {
 	readonly runBudgetSeconds: number;
 	/** Wall-clock kill deadline for a single cell; bounds detached and bridge-parked cells too. */
 	readonly hardLimitSeconds: number;
+	/** Maximum detached cells across all language kernels. */
+	readonly maxDetachedCells?: number;
 	readonly parallelPoolWidth: number;
 	readonly taskTools?: CodemodeTaskTools;
 	readonly outputSink?: CodemodeOutputSink;
@@ -87,6 +90,7 @@ export interface CodemodeSettings {
 }
 
 export type ResolvedCodemodeSettings = CodemodeSettings & {
+	readonly maxDetachedCells: number;
 	readonly taskTools: CodemodeTaskTools;
 	readonly outputSink: CodemodeOutputSink;
 	readonly statusEvents: boolean;
@@ -129,7 +133,10 @@ export const FOREGROUND_WINDOW_ENVIRONMENT_FLAG = "SENPI_CODEMODE_FOREGROUND_SEC
  */
 export const DEFAULT_RUN_BUDGET_SECONDS = 300;
 
+export const DEFAULT_MAX_DETACHED_CELLS = 15;
+
 export const RUN_BUDGET_ENVIRONMENT_FLAG = "SENPI_CODEMODE_RUN_BUDGET_SECONDS";
+export const MAX_DETACHED_CELLS_ENVIRONMENT_FLAG = "SENPI_CODEMODE_MAX_DETACHED_CELLS";
 
 // OMP settings-schema.ts:3211-3299 has language/path settings only; eval.ts:427
 // defaults timeout to 30s, and codemode pins concurrency-bridge.ts:30 width to 4.
@@ -144,6 +151,7 @@ export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 	foregroundWindowSeconds: DEFAULT_FOREGROUND_WINDOW_SECONDS,
 	runBudgetSeconds: DEFAULT_RUN_BUDGET_SECONDS,
 	hardLimitSeconds: DEFAULT_HARD_LIMIT_SECONDS,
+	maxDetachedCells: DEFAULT_MAX_DETACHED_CELLS,
 	parallelPoolWidth: 4,
 	taskTools: {
 		task: "task",
@@ -207,6 +215,15 @@ export function resolveRunBudgetSeconds(settings: CodemodeSettings, env: Environ
 	return positiveSecondsOverride(env[RUN_BUDGET_ENVIRONMENT_FLAG]) ?? settings.runBudgetSeconds;
 }
 
+/** Uses the same positive-integer environment parsing as the run budget. */
+export function resolveMaxDetachedCells(settings: CodemodeSettings, env: Environment = process.env): number {
+	return (
+		positiveSecondsOverride(env[MAX_DETACHED_CELLS_ENVIRONMENT_FLAG]) ??
+		settings.maxDetachedCells ??
+		DEFAULT_MAX_DETACHED_CELLS
+	);
+}
+
 function positiveSecondsOverride(value: string | undefined): number | undefined {
 	if (value === undefined) return undefined;
 	const parsed = Number.parseInt(value, 10);
@@ -250,6 +267,7 @@ function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 		foregroundWindowSeconds: input.foregroundWindowSeconds ?? defaultCodemodeSettings.foregroundWindowSeconds,
 		runBudgetSeconds: input.runBudgetSeconds ?? defaultCodemodeSettings.runBudgetSeconds,
 		hardLimitSeconds: input.hardLimitSeconds ?? defaultCodemodeSettings.hardLimitSeconds,
+		maxDetachedCells: input.maxDetachedCells ?? DEFAULT_MAX_DETACHED_CELLS,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
 		taskTools: {
 			task: input.taskTools?.task ?? defaultCodemodeSettings.taskTools.task,

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/eval-status.ts

@@ -28,7 +28,8 @@ function packLabels(labels: readonly string[], budget: number): string {
 }
 
 function labelOf(entry: EvalDetachedCellStatusEntry): string {
-	return entry.summary === undefined || entry.summary.length === 0 ? entry.cellId : entry.summary;
+	const label = entry.summary === undefined || entry.summary.length === 0 ? entry.cellId : entry.summary;
+	return entry.queuedBehind === undefined ? label : `queued ${label}`;
 }
 
 /**
@@ -52,10 +53,12 @@ export function formatElapsedSeconds(value: number): string {
 	return `${hours}h ${remainingMinutes}m`;
 }
 
-/** Whole seconds since the oldest detached cell was created; never negative on clock skew. */
+/** Whole seconds since the oldest executing detached cell started; queued cells do not tick. */
 export function evalCellElapsedSeconds(entries: readonly EvalDetachedCellStatusEntry[], nowMs: number): number {
 	let oldest = Number.POSITIVE_INFINITY;
-	for (const entry of entries) oldest = Math.min(oldest, entry.startedAtMs);
+	for (const entry of entries) {
+		if (entry.queuedBehind === undefined) oldest = Math.min(oldest, entry.startedAtMs);
+	}
 	if (!Number.isFinite(oldest)) return 0;
 	return Math.max(0, Math.round((nowMs - oldest) / 1000));
 }
@@ -67,7 +70,9 @@ export function formatEvalCellStatus(
 ): string | undefined {
 	const first = entries[0];
 	if (first === undefined) return undefined;
-	const suffix = ` (${formatElapsedSeconds(evalCellElapsedSeconds(entries, nowMs))})`;
+	const suffix = entries.every((entry) => entry.queuedBehind !== undefined)
+		? " (queued)"
+		: ` (${formatElapsedSeconds(evalCellElapsedSeconds(entries, nowMs))})`;
 	if (entries.length === 1) {
 		const head = `${DETACHED_GLYPH} ${first.language} · `;
 		return head + truncateEnd(labelOf(first), MAX_STATUS_LENGTH - head.length - suffix.length) + suffix;

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -7,6 +7,7 @@ import {
 	defaultCodemodeSettings,
 	resolveForegroundWindowSeconds,
 	resolveHardLimitSeconds,
+	resolveMaxDetachedCells,
 	resolveRunBudgetSeconds,
 } from "./config/settings.ts";
 import { EvalNotifier } from "./extension/eval-notifier.ts";
@@ -113,6 +114,9 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		statusTicker.sync(entries);
 	};
 	const emitWakeSourceState = (state: WakeSourceState): void => {
+		// Same dual publication as the settle payload below: the in-process bus
+		// feeds the TUI footer, the rpc channel feeds out-of-process consumers.
+		pi.rpc?.emit(WAKE_SOURCE_STATE_EVENT, state);
 		pi.events?.emit(WAKE_SOURCE_STATE_EVENT, state);
 	};
 	const registerEvalForRuntime = (
@@ -181,6 +185,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			settings: defaultCodemodeSettings,
 			cellManager: new EvalDetachedCellManager({
 				notifier,
+				maxDetachedCells: resolveMaxDetachedCells(defaultCodemodeSettings),
 				hardLimitSeconds: resolveHardLimitSeconds(defaultCodemodeSettings),
 				runBudgetSeconds: resolveRunBudgetSeconds(defaultCodemodeSettings),
 				onStatusChange: showDetachedCells,
@@ -219,6 +224,7 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		const cellManager = new EvalDetachedCellManager({
 			artifactsDir: runtime.artifactsDir,
 			notifier,
+			maxDetachedCells: resolveMaxDetachedCells(runtime.settings),
 			hardLimitSeconds: resolveHardLimitSeconds(runtime.settings),
 			runBudgetSeconds: resolveRunBudgetSeconds(runtime.settings),
 			onStatusChange: showDetachedCells,

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/AGENTS.md

@@ -28,8 +28,8 @@ runner/prelude assets).
   AST-parsed (Babel) and rewritten to bridge-compatible dynamic imports.
 - JS runs on worker threads with an inline-worker fallback; py/rb/jl run as
   framed subprocesses through `shared/`.
-- Subprocess retirement/restart, worker recovery, timeout, and interrupt
-  semantics live here, never in the tool layer.
+- Each language keeps one serial FIFO kernel. Queued cancellation removes only
+  that cell; active interruption and runtime recovery stay in the kernel layer.
 - Every kernel exposes the active session's `PI_*` environment (`session-env.ts`):
   inherited values are deleted before the session's values are applied, so any
   child spawned from a cell sees the same session environment a bash-tool child

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/jl/prelude.jl

@@ -254,6 +254,12 @@ function output(ids...; format="raw", offset=nothing, limit=nothing)
     senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__output__", arguments))
 end
 
+"""
+Delegate work with isolated/apply/merge; needs a host that supports isolation, otherwise a warning.
+merge accepts "patch"/"branch" (false/true aliases). Unapplied foreground changes raise
+an error with recovery instructions. Handles return immediately: await the completion
+notification or read task_output for the isolation result.
+"""
 function agent(prompt::AbstractString; agent="task", model=nothing, label=nothing, schema=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
     arguments = Dict{String, Any}("prompt" => string(prompt), "agent" => agent)
     for (key, value) in (("model", model), ("label", label), ("schema", schema), ("isolated", isolated), ("apply", apply), ("merge", merge))
@@ -272,6 +278,10 @@ function agent(prompt::AbstractString; agent="task", model=nothing, label=nothin
     result["handle"] = get(record, "handle", result["id"] === nothing ? nothing : "agent://" * string(result["id"]))
     result["run_epoch"] = get(record, "run_epoch", nothing)
     schema !== nothing && (result["data"] = parsed)
+    details = get(record, "details", nothing)
+    if details isa AbstractDict && haskey(details, "isolation")
+        result["details"] = Dict("isolation" => details["isolation"])
+    end
     result
 end
 

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/context-manager.ts

@@ -90,13 +90,26 @@ export class JavaScriptKernel {
 		return await promise;
 	}
 
-	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
+	cancelQueued(cellId: string, reason: string): boolean {
+		return this.#runs.remove(cellId, reason);
+	}
+
+	queueSnapshot(): { activeCellId: string | null; queuedCellIds: readonly string[] } {
+		return this.#runs.snapshot();
+	}
+
+	async interrupt(reason = "interrupted", cellId?: string): Promise<KernelInterruptHandle> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "interrupt");
 		const active = this.#runs.active;
+		if (cellId !== undefined && active?.input.cellId !== cellId) {
+			const cancelled = this.cancelQueued(cellId, reason);
+			return { stateRetained: Promise.resolve(true), ...(cancelled ? {} : { note: "cell not found" }) };
+		}
 		if (!active) {
-			const queued = this.#runs.takeInterruptTarget();
-			if (!queued) return { stateRetained: Promise.resolve(true) };
-			this.#runs.settle(queued, stoppedResult(queued.input.cellId, `JS cell interrupted: ${reason}`));
+			// A worker still stuck in startup is not a healthy idle worker: retiring it is the only recovery.
+			const wedgedInStartup = this.#slot.startingUp;
+			this.#runs.settleAll(`JS cell interrupted: ${reason}`);
+			if (!wedgedInStartup) return { stateRetained: Promise.resolve(true) };
 			await this.#restartAfterStop();
 			return { stateRetained: Promise.resolve(false) };
 		}
@@ -262,8 +275,7 @@ export class JavaScriptKernel {
 			this.#trackChildEvent(message.event);
 			return;
 		}
-		this.#options.onMessage?.(message);
-		this.#runs.active?.input.onMessage?.(message);
+		(this.#runs.active?.input.onMessage ?? this.#options.onMessage)?.(message);
 		if (message.type === "tool-call") {
 			const waiter = this.#toolWaiters.shift();
 			if (waiter) waiter(message);

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-contract.ts

@@ -1,4 +1,5 @@
 import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 
 export type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
@@ -28,12 +29,7 @@ export interface JavaScriptKernelOptions {
 	readonly foreignLanguageNames?: KernelToolNameSource;
 }
 
-export interface JavaScriptRunInput {
-	readonly cellId: string;
-	readonly code: string;
-	readonly timeoutMs?: number;
-	readonly onMessage?: (message: KernelToHostMessage) => void;
-}
+export type JavaScriptRunInput = EvalKernelRunInput;
 
 export type KernelOperation = "run" | "reset" | "interrupt";
 export type LifecycleState = "open" | "closing" | "closed";

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/prelude.ts

@@ -10,7 +10,7 @@ export const JAVASCRIPT_KERNEL_PRELUDE = [
 	"tool(fn, metadata?): register a named JavaScript function as a fenced kernel tool for in-process children.",
 	"completion(prompt, options?): request a host completion bridge call.",
 	"output(...ids, options?): retrieve task output through the reserved output bridge.",
-	"agent(prompt, options?): delegate work through the reserved agent bridge.",
+	'agent(prompt, options?): delegate work; isolated/apply/merge need a host that supports isolation, otherwise a warning. merge: "patch"/"branch" (false/true aliases). Unapplied foreground changes throw with recovery instructions. Handles return immediately; await the completion notification or read task_output for the isolation result.',
 	"workpool(agent, name, options?): await a host-owned pool adapter with pool_id, push, close, inspect, and cancel; options only accept mode.",
 	"parallel(thunks): run async thunks through the configured bounded pool; preserves order and rethrows the lowest-index error after all settle.",
 	"pipeline(items, ...stages): map items through staged async transforms with a barrier between stages.",

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/run-queue.ts

@@ -49,21 +49,31 @@ export class JavaScriptRunQueue {
 		const next = this.#queue.shift() ?? null;
 		if (next) next.startedAtMs = startedAtMs;
 		this.#active = next;
+		next?.input.onStarted?.();
 		return next;
 	}
 
+	remove(cellId: string, reason = "interrupted"): boolean {
+		const index = this.#queue.findIndex((run) => run.input.cellId === cellId);
+		if (index < 0) return false;
+		const [run] = this.#queue.splice(index, 1);
+		if (!run) return false;
+		this.settle(run, stoppedResult(cellId, reason));
+		return true;
+	}
+
+	snapshot(): { activeCellId: string | null; queuedCellIds: readonly string[] } {
+		return {
+			activeCellId: this.#active?.input.cellId ?? null,
+			queuedCellIds: this.#queue.map((run) => run.input.cellId),
+		};
+	}
+
 	durationMs(run: PendingJavaScriptRun, finishedAtMs: number): number {
 		if (run.startedAtMs === null) return 0;
 		return Math.max(0, Math.round(finishedAtMs - run.startedAtMs));
 	}
 
-	takeInterruptTarget(): PendingJavaScriptRun | null {
-		if (!this.#active) return this.#queue.shift() ?? null;
-		const active = this.#active;
-		this.#active = null;
-		return active;
-	}
-
 	releaseActive(run: PendingJavaScriptRun): boolean {
 		if (this.#active !== run) return false;
 		this.#active = null;

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/worker-runtime.js

@@ -305,7 +305,9 @@ export class JsWorkerRuntime {
 				: JSON.parse(String(text))
 			: text;
 		if (!handle) return output;
-		const details = isPlainObject(responseRecord.details) ? responseRecord.details : responseRecord;
+		const details = Object.hasOwn(responseRecord, "id")
+			? responseRecord
+			: isPlainObject(responseRecord.details) ? responseRecord.details : responseRecord;
 		const id = details.id;
 		if (id === undefined || id === null) return { text, output: text, handle: null, id: null, agent: null };
 		const node = {
@@ -317,6 +319,9 @@ export class JsWorkerRuntime {
 			agent: details.agent ?? callArgs.agent ?? null,
 		};
 		if (Object.hasOwn(callArgs, "schema")) node.data = output;
+		if (isPlainObject(responseRecord.details) && Object.hasOwn(responseRecord.details, "isolation")) {
+			node.details = { isolation: responseRecord.details.isolation };
+		}
 		for (const key of ["isolated", "patchPath", "branchName", "nestedPatches", "changesApplied", "isolationSummary"]) {
 			if (details[key] !== undefined) node[key] = details[key];
 		}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/py/kernel-contract.ts

@@ -1,4 +1,5 @@
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import type { KernelSpawnProcess } from "./process.ts";
 import type { PythonTransportResult } from "./transport.ts";
@@ -16,11 +17,7 @@ export interface PythonKernelStartOptions {
 	readonly spawnProcess?: KernelSpawnProcess;
 }
 
-export interface PythonKernelRunOptions {
-	readonly cellId: string;
-	readonly code: string;
-	readonly timeoutMs?: number;
-}
+export type PythonKernelRunOptions = EvalKernelRunInput;
 
 export type ResultMessage = PythonTransportResult;