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

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

@@ -56,11 +56,31 @@ export class PythonKernel {
 		});
 	}
 
-	async interrupt(reason = "interrupted"): Promise<KernelInterruptHandle> {
+	cancelQueued(cellId: string, reason: string): boolean {
+		const pending = this.#queue.find((run) => run.input.cellId === cellId);
+		if (!pending) return false;
+		this.#settleRun(pending, failedPythonResult(cellId, reason));
+		return true;
+	}
+
+	queueSnapshot(): { activeCellId: string | null; queuedCellIds: readonly string[] } {
+		return {
+			activeCellId: this.#active?.input.cellId ?? null,
+			queuedCellIds: this.#queue.map((run) => run.input.cellId),
+		};
+	}
+
+	async interrupt(reason = "interrupted", cellId?: string): Promise<KernelInterruptHandle> {
 		if (this.#failure) throw this.#failure;
-		for (const pending of [...this.#queue]) {
-			pending.interruptReason = reason;
-			this.#settleRun(pending, failedPythonResult(pending.input.cellId, "Eval interrupted"));
+		if (cellId !== undefined && this.#active?.input.cellId !== cellId) {
+			const cancelled = this.cancelQueued(cellId, reason);
+			return { stateRetained: Promise.resolve(true), ...(cancelled ? {} : { note: "cell not found" }) };
+		}
+		if (cellId === undefined) {
+			for (const pending of [...this.#queue]) {
+				pending.interruptReason = reason;
+				this.#settleRun(pending, failedPythonResult(pending.input.cellId, "Eval interrupted"));
+			}
 		}
 		const active = this.#active;
 		const transport = this.#transport;
@@ -155,6 +175,7 @@ export class PythonKernel {
 		if (!pending || !this.#pending.has(pending.input.cellId)) return;
 		this.#active = pending;
 		pending.startedAt = performance.now();
+		pending.input.onStarted?.();
 		const timeoutMs = pending.input.timeoutMs;
 		if (timeoutMs !== undefined)
 			pending.timeoutTimer = setTimeout(() => this.#timeoutRun(pending, timeoutMs), timeoutMs);
@@ -191,6 +212,14 @@ export class PythonKernel {
 		if (this.#closed || generation !== this.#generation) throw new Error("Python kernel startup was superseded");
 		this.#transport = await PythonKernelTransport.start({
 			...this.#options,
+			onMessage: (message) => {
+				if (message.type === "result") return;
+				const callback =
+					message.type === "ready" || message.type === "init-failed" || message.type === "closed"
+						? this.#options.onMessage
+						: (this.#active?.input.onMessage ?? this.#options.onMessage);
+				callback?.(message);
+			},
 			startupTimeoutMs: this.#options.startupTimeoutMs ?? startupTimeoutMs,
 			isOwned: () => !this.#closed && generation === this.#generation,
 			onRetirementFailure: (transport, error) => {
@@ -206,7 +235,10 @@ export class PythonKernel {
 	#onResult(transport: PythonKernelTransport, result: ResultMessage): void {
 		if (this.#transport !== transport) return;
 		const pending = this.#pending.get(result.cellId);
-		if (pending) this.#settleRun(pending, result);
+		if (pending) {
+			(pending.input.onMessage ?? this.#options.onMessage)?.(result);
+			this.#settleRun(pending, result);
+		}
 		// A result frame from the live runner proves the process survived the interrupt.
 		if (pending?.resolveStateRetained) pending.resolveStateRetained(true);
 	}

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

@@ -529,9 +529,15 @@ def agent(
     schema: dict[str, Any] | None = None,
     isolated: bool | None = None,
     apply: bool | None = None,
-    merge: bool | None = None,
+    merge: bool | str | None = None,
     handle: bool = False,
 ) -> Any:
+    """Delegate work; isolated/apply/merge need a host that supports isolation, otherwise a warning.
+
+    merge accepts "patch"/"branch" or False/True respectively. Unapplied foreground
+    changes raise an error with recovery instructions. A handle returns immediately;
+    await the completion notification or read task_output for the isolation result.
+    """
     args: dict[str, Any] = {"prompt": prompt}
     if agent is not None:
         args["agent"] = agent
@@ -546,7 +552,7 @@ def agent(
     if apply is not None:
         args["apply"] = bool(apply)
     if merge is not None:
-        args["merge"] = bool(merge)
+        args["merge"] = merge
     if handle:
         args["handle"] = True
 
@@ -578,6 +584,9 @@ def agent(
     }
     if schema is not None:
         node["data"] = parsed
+    details = response_record.get("details")
+    if isinstance(details, dict) and "isolation" in details:
+        node["details"] = {"isolation": details["isolation"]}
     for key in (
         "isolated",
         "patch_path",

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

@@ -213,6 +213,10 @@ def output(*ids, format: "raw", offset: nil, limit: nil)
   __senpi_call_tool(SENPI_RESERVED_OUTPUT_TOOL, args)
 end
 
+# isolated/apply/merge need a host that supports isolation; otherwise a warning.
+# merge: "patch"/"branch" (false/true aliases). Unapplied foreground changes raise
+# an error with recovery instructions. Handles return immediately: await completion
+# notification or read task_output for the isolation result.
 def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated: nil, apply: nil, merge: nil, handle: false)
   args = { "prompt" => prompt.to_s, "agent" => agent }
   { "model" => model, "label" => label, "schema" => schema, "isolated" => isolated, "apply" => apply, "merge" => merge }.each do |key, value|
@@ -226,6 +230,8 @@ def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated:
   return result unless handle
   { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "run_epoch" => record["run_epoch"], "agent" => record.fetch("agent", agent) }.tap do |node|
     node["data"] = result unless schema.nil?
+    details = record["details"]
+    node["details"] = { "isolation" => details["isolation"] } if details.is_a?(Hash) && details.key?("isolation")
   end
 end
 

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-contract.ts

@@ -1,12 +1,9 @@
 import type { BridgeConnectionConfig, KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { EvalKernelRunInput } from "../../tool/types.ts";
 import type { SessionEnvironment } from "../session-env.ts";
 import type { SubprocessSpawn } from "./subprocess-process.ts";
 
-export interface KernelRunInput {
-	readonly cellId: string;
-	readonly code: string;
-	readonly timeoutMs?: number;
-}
+export type KernelRunInput = EvalKernelRunInput;
 
 export type KernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-kernel.ts

@@ -49,12 +49,22 @@ export class SubprocessKernel {
 		return run;
 	}
 
-	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> {
+		if (cellId !== undefined && this.runs.active?.input.cellId !== cellId) {
+			const cancelled = this.cancelQueued(cellId, reason);
+			return { stateRetained: Promise.resolve(true), ...(cancelled ? {} : { note: "cell not found" }) };
+		}
 		if (this.closed) return { stateRetained: Promise.resolve(true) };
 		if (!this.runs.active) {
-			if (!this.retirementPromise) return { stateRetained: Promise.resolve(true) };
-			const queued = this.runs.takeWaiting();
-			if (queued) this.runs.settle(queued, failureResult(queued, new CellInterruptedError(reason)));
+			this.runs.settleAll(new CellInterruptedError(reason));
 			return { stateRetained: Promise.resolve(true) };
 		}
 		const process = this.process;

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/shared/subprocess-queue.ts

@@ -24,11 +24,24 @@ export class SubprocessRunQueue {
 		const next = this.#queue.shift() ?? null;
 		if (next) next.startedAt = startedAt;
 		this.#active = next;
+		next?.input.onStarted?.();
 		return next;
 	}
 
-	takeWaiting(): PendingRun | null {
-		return this.#queue.shift() ?? null;
+	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, failureResult(run, new Error(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),
+		};
 	}
 
 	releaseActive(run: PendingRun): boolean {
@@ -76,14 +89,14 @@ export class SubprocessRunQueue {
 			case "result": {
 				const run = this.#active;
 				if (!run || run.input.cellId !== message.cellId) return false;
-				onMessage?.(message);
+				(run.input.onMessage ?? onMessage)?.(message);
 				this.releaseActive(run);
 				this.settle(run, message);
 				return true;
 			}
 			case "tool-call":
 				if (!this.#active) return false;
-				onMessage?.(message);
+				(this.#active.input.onMessage ?? onMessage)?.(message);
 				this.pushToolCall(message);
 				return false;
 			case "text":
@@ -91,7 +104,7 @@ export class SubprocessRunQueue {
 			case "log":
 			case "phase":
 			case "status":
-				if (this.#active) onMessage?.(message);
+				if (this.#active) (this.#active.input.onMessage ?? onMessage)?.(message);
 				return false;
 			case "ready":
 			case "init-failed":

package/node_modules/@code-yeongyu/senpi-codemode/src/prompt/eval-prompt-template.ts

@@ -26,7 +26,7 @@ Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to it
 
 \`language\`: {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
 
-A cell that outlives the foreground window detaches: it keeps its language kernel busy (another language can continue) and completes as one notification with its value or error and buffered output. Its own execution time is capped at {{runBudgetSeconds}}s — time inside host tool calls is not charged; raise \`timeout\` only for a declared long run — and a killed js cell that cannot settle restarts its kernel with every global lost. Do not re-run a detached cell; read or cancel it with \`eval({ action: "peek", cell_id })\` / \`eval({ action: "stop", cell_id })\`.
+A cell that outlives the foreground window detaches and keeps running; further cells on the same language queue behind it in submission order on the same kernel (state is shared, execution is serial) while other languages run at once, up to {{maxDetachedCells}} background cells per session; each detached cell completes as one notification. Do not re-run a detached or queued cell; read, cancel or enumerate them with \`eval({ action: "peek" | "stop", cell_id })\` / \`eval({ action: "list" })\`; list shows live and recently settled cells across languages without consuming notifications. Its own execution time is capped at {{runBudgetSeconds}}s — queue time and time inside host tool calls are not charged; the hard limit stays wall-clock from submission; raise \`timeout\` only for a declared long run — and a killed js cell that cannot settle restarts its kernel with every global lost.
 
 {{#if py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
 {{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot. Shell out through \`Bun.$\` or \`Bun.spawn\`, never \`Bun.spawnSync\`: a synchronous child blocks the worker and cannot be interrupted.{{#if bunSkillPath}} MUST READ the bun-1-4 skill at {{bunSkillPath}} before your first js cell — its builtins replace the npm packages you would otherwise install.{{/if}}{{else}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}{{/if}}
@@ -56,7 +56,8 @@ tool_schema(name?) → dict
     Parameter schema of a tool (omit \`name\` to list tool names); a failed \`tool.<name>()\` call also returns the expected parameters.
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
     Oneshot, stateless. \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → parsed structured output.
-{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
+{{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, isolated?=None, apply?=None, merge?=None, handle?=False) → str | dict
+    Isolation options 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.
     Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, run_epoch, agent } (parsed under \`data\` with \`schema\`).
 {{/if}}workpool(agent, name, mode?) → { pool_id, push(items), close(), inspect(), cancel() }
     Thin host-tool adapter; agent is a plain-data spec. The host owns scheduling and keyed yields; explicitly close for automatic aggregate delivery. Requires the host workpool tool; omitted mode uses its default.

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

@@ -1,4 +1,4 @@
-import { DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
+import { DEFAULT_MAX_DETACHED_CELLS, DEFAULT_RUN_BUDGET_SECONDS } from "../config/settings.ts";
 import type { EvalRuntimeInfo } from "../tool/types.ts";
 import { EVAL_PROMPT_TEMPLATE } from "./eval-prompt-template.ts";
 
@@ -30,6 +30,8 @@ export interface EvalPromptOptions {
 	readonly bunSkillPath?: string;
 	/** Kill deadline for a cell's own execution time, as configured; the description states it. */
 	readonly runBudgetSeconds?: number;
+	/** Global background capacity advertised to the model. */
+	readonly maxDetachedCells?: number;
 }
 
 /** Prompt dialect for the eval-first batching emphasis. */
@@ -96,6 +98,7 @@ export function buildEvalPrompt(
 		jsVersion: options.jsRuntime?.version ?? "",
 		bunSkillPath: options.bunSkillPath ?? "",
 		runBudgetSeconds: String(options.runBudgetSeconds ?? DEFAULT_RUN_BUDGET_SECONDS),
+		maxDetachedCells: String(options.maxDetachedCells ?? DEFAULT_MAX_DETACHED_CELLS),
 	};
 	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
 		.replace(/\n{3,}/g, "\n\n")

package/node_modules/@code-yeongyu/senpi-codemode/src/timeouts/idle-timeout.ts

@@ -15,6 +15,8 @@ export interface IdleTimeoutOptions {
 	readonly timeoutMs: number;
 	/** Defaults to {@link DEFAULT_MAX_PAUSE_GRACE_MS}; floored at `timeoutMs` so a pause never shortens the budget. */
 	readonly maxPauseGraceMs?: number;
+	/** Optional absolute deadline that neither idle resets nor bridge pauses may extend. */
+	readonly deadlineMs?: number;
 	readonly onTimeout: (event: IdleTimeoutEvent) => void;
 }
 
@@ -26,6 +28,7 @@ export interface TimeoutPauseHandle {
 export class IdleTimeout implements TimeoutPauseHandle {
 	readonly #cellId: string;
 	readonly #onTimeout: (event: IdleTimeoutEvent) => void;
+	readonly #absoluteDeadlineMs: number;
 	readonly #controller = new AbortController();
 	readonly signal = this.#controller.signal;
 	readonly timeoutMs: number;
@@ -38,6 +41,7 @@ export class IdleTimeout implements TimeoutPauseHandle {
 
 	constructor(options: IdleTimeoutOptions) {
 		this.#cellId = options.cellId;
+		this.#absoluteDeadlineMs = options.deadlineMs ?? Number.POSITIVE_INFINITY;
 		this.timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
 		this.maxPauseGraceMs = Math.max(
 			this.timeoutMs,
@@ -78,7 +82,10 @@ export class IdleTimeout implements TimeoutPauseHandle {
 
 	#arm(delayMs: number): void {
 		this.#clearTimer();
-		const timer = setTimeout(() => this.#expire(), Math.max(0, delayMs));
+		const timer = setTimeout(
+			() => this.#expire(),
+			Math.max(0, Math.min(delayMs, this.#absoluteDeadlineMs - Date.now())),
+		);
 		timer.unref?.();
 		this.#timer = timer;
 	}
@@ -93,7 +100,7 @@ export class IdleTimeout implements TimeoutPauseHandle {
 		if (this.#settled) return;
 		const pausedDeadlineMs = this.#pausedDeadlineMs;
 		if (this.#pauseDepth > 0 && pausedDeadlineMs === undefined) return;
-		const deadlineMs = pausedDeadlineMs ?? this.#deadlineMs;
+		const deadlineMs = Math.min(pausedDeadlineMs ?? this.#deadlineMs, this.#absoluteDeadlineMs);
 		const remainingMs = deadlineMs - Date.now();
 		if (remainingMs > 0) {
 			this.#arm(remainingMs);

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

@@ -26,6 +26,8 @@ anchor most suites).
 - Detached execution is a first-class state machine — snapshot, notification
   queue, spill-file notice, result conversion — never folded into ordinary
   cell execution.
+- Cells enter `queued`, then `running`; detachment is orthogonal. Per-run kernel callbacks own output, never the latest language-level callback. Queued cells consume no run budget; the hard limit remains wall-clock from submission. Elapsed execution time starts at `runStartedAtMs`.
+- `maxDetachedCells` (default 15, `SENPI_CODEMODE_MAX_DETACHED_CELLS` override) caps detached cells globally, including queued cells. Excess cells stay foreground until completion or the foreground deadline; queued stop preserves the active cell.
 - Unicode tree glyphs and status icons are intentional UI conventions.
 
 ## ANTI-PATTERNS

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/cell-execution.ts

@@ -37,10 +37,12 @@ const NO_WATCHDOG: TimeoutPauseHandle & { dispose(): void } = {
 
 export class CellExecution {
 	readonly #callerSignal: AbortSignal;
+	readonly #cellId: string;
 	readonly #onAbort: (error: Error) => void;
 	readonly #abortPromise: Promise<never>;
 	readonly #detachedPromise: Promise<void>;
-	readonly #watchdog: TimeoutPauseHandle & { dispose(): void };
+	readonly #timeoutFactory: EvalTimeoutFactory;
+	#watchdog: TimeoutPauseHandle & { dispose(): void };
 	#rejectAbort: ((reason?: unknown) => void) | undefined;
 	#resolveDetached: (() => void) | undefined;
 	#kernel: EvalKernel | undefined;
@@ -48,7 +50,9 @@ export class CellExecution {
 	#active = true;
 
 	constructor(options: CellExecutionOptions) {
+		this.#timeoutFactory = options.timeoutFactory;
 		this.#callerSignal = options.callerSignal;
+		this.#cellId = options.cellId;
 		this.#onAbort = options.onAbort;
 		this.#abortPromise = new Promise<never>((_resolve, reject) => {
 			this.#rejectAbort = reject;
@@ -64,6 +68,7 @@ export class CellExecution {
 						cellId: options.cellId,
 						timeoutMs: idle.timeoutMs,
 						maxPauseGraceMs: idle.maxPauseGraceMs,
+						deadlineMs: Date.now() + idle.maxPauseGraceMs,
 						onTimeout: ({ error }) => idle.onTimeout(error),
 					});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {
@@ -83,6 +88,18 @@ export class CellExecution {
 		this.#watchdog.resume();
 	}
 
+	/** One final submission-window wait after background admission was refused; pauses cannot extend it. */
+	rearmIdle(timeoutMs: number, onTimeout: () => void): void {
+		this.#watchdog.dispose();
+		this.#watchdog = this.#timeoutFactory.create({
+			cellId: this.#cellId,
+			timeoutMs,
+			maxPauseGraceMs: timeoutMs,
+			deadlineMs: Date.now() + timeoutMs,
+			onTimeout,
+		});
+	}
+
 	setKernel(kernel: EvalKernel): void {
 		this.#kernel = kernel;
 	}
@@ -130,7 +147,7 @@ export class CellExecution {
 			return;
 		}
 		this.#interruptDeadline = setTimeout(() => this.#settleAbort(error), INTERRUPT_DELIVERY_GRACE_MS);
-		const handle = Promise.resolve().then(async () => await kernel.interrupt(error.message));
+		const handle = Promise.resolve().then(async () => await kernel.interrupt(error.message, this.#cellId));
 		this.interruptHandle = handle;
 		void handle.then(
 			() => this.#settleAbort(error),

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/cell-runtime.ts

@@ -12,6 +12,8 @@ export interface CellState {
 	readonly input: EvalToolInput;
 	readonly runtime?: EvalRuntimeInfo;
 	readonly startedAt: number;
+	runStartedAt?: number | undefined;
+	queuedBehind?: readonly string[] | undefined;
 	readonly signal: AbortSignal;
 	readonly onUpdate: AgentToolUpdateCallback<EvalToolDetails> | undefined;
 	readonly toolCalls: ToolCall[];
@@ -23,7 +25,7 @@ export interface CellState {
 	phase: string | undefined;
 	error: string | undefined;
 	durationMs: number;
-	status: "pending" | "running" | "complete" | "error";
+	status: "pending" | "queued" | "running" | "complete" | "error";
 }
 
 export interface CellResultBuilderOptions {
@@ -52,7 +54,7 @@ export class CellResultBuilder {
 				this.emitUpdate(false);
 			},
 		});
-		options.state.status = "running";
+		if (options.state.status !== "queued") options.state.status = "running";
 		this.emitUpdate(false);
 	}
 
@@ -145,7 +147,10 @@ export class CellResultBuilder {
 					output: this.#state.output,
 					status: this.#state.status,
 					durationMs: this.#state.durationMs,
-					startedAt: this.#state.startedAt,
+					...(this.#state.status === "queued"
+						? {}
+						: { startedAt: this.#state.runStartedAt ?? this.#state.startedAt }),
+					...(this.#state.queuedBehind === undefined ? {} : { queuedBehind: this.#state.queuedBehind }),
 					...(statusEvents === undefined ? {} : { statusEvents }),
 					...(output?.hasMarkdown ? { hasMarkdown: true } : {}),
 				},
@@ -158,6 +163,9 @@ export class CellResultBuilder {
 	}
 
 	#liveUpdateText(): string {
+		if (this.#state.status === "queued" && this.#state.queuedBehind?.length) {
+			return `queued behind ${this.#state.queuedBehind.join(", ")} in the ${this.#state.input.language} kernel`;
+		}
 		const summary = this.#state.input.summary === undefined ? "" : ` ${this.#state.input.summary}`;
 		const aggregateOutput = this.#output.aggregateText();
 		const outputLines = aggregateOutput.split("\n");

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/detached-cell-contract.ts

@@ -2,12 +2,14 @@ import type { AgentToolResult } from "@code-yeongyu/senpi";
 import type { WakeSourceState } from "../extension/wake-source-state.ts";
 import type { EvalLanguage, EvalToolDetails } from "./types.ts";
 
-export type EvalDetachedCellState = "running" | "detached" | "completed" | "failed" | "cancelled";
+export type EvalDetachedCellState = "queued" | "running" | "detached" | "completed" | "failed" | "cancelled";
 
 export interface EvalDetachedCellSnapshot {
 	readonly cellId: string;
 	readonly language: EvalLanguage;
+	readonly startedAtMs: number;
 	readonly state: EvalDetachedCellState;
+	readonly queuedBehind?: readonly string[];
 	readonly outputTail: string;
 	readonly result: AgentToolResult<EvalToolDetails>;
 	readonly stateRetained: boolean | undefined;
@@ -33,6 +35,7 @@ export interface EvalDetachedCellStatusEntry {
 	readonly language: EvalLanguage;
 	readonly summary?: string;
 	readonly startedAtMs: number;
+	readonly queuedBehind?: readonly string[];
 }
 
 export interface EvalDetachedCellManagerOptions {
@@ -42,6 +45,8 @@ export interface EvalDetachedCellManagerOptions {
 	readonly hardLimitSeconds?: number;
 	/** Kill deadline for a cell's own execution time in seconds; a per-call `timeout` replaces it. Defaults to 300s. */
 	readonly runBudgetSeconds?: number;
+	/** Global detached-cell capacity; defaults to 15. Full capacity keeps new cells foreground. */
+	readonly maxDetachedCells?: number;
 	readonly onStatusChange?: (entries: readonly EvalDetachedCellStatusEntry[]) => void;
 	/** Receives a full per-source liveness snapshot on every detached-cell transition; used by the goal builtin. */
 	readonly onWakeSourceState?: (state: WakeSourceState) => void;