@code-yeongyu/senpi 2026.9.15 → 2026.9.16

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

@@ -1,3 +1,6 @@
+import { kernelToolCallContext } from "./kernel-tools-context.js";
+import { kernelToolError } from "./kernel-tools-errors.js";
+import { createKernelToolPump } from "./kernel-tools-pump.js";
 import { JsWorkerRuntime } from "./worker-runtime.js";
 
 // Mirrors INTERRUPT_ACK_OP and CHILD_LIFECYCLE_OP in src/bridge/reserved.ts (this worker file cannot import TypeScript).
@@ -21,6 +24,12 @@ export function createWorkerCore(transport, options) {
 	let runtime = null;
 	let activeCell = null;
 	const pendingTools = new Map();
+	const nestedInvokes = new Map();
+	const kernelTools = createKernelToolPump({
+		getRuntime: () => runtime,
+		emit: (message) => transport.send(message),
+		nestedInvokes,
+	});
 
 	function emit(message) {
 		transport.send(message);
@@ -47,9 +56,12 @@ export function createWorkerCore(transport, options) {
 	}
 
 	async function callTool(toolName, args) {
-		if (activeCell?.interruption) throw activeCell.interruption;
+		const nested = kernelToolCallContext.getStore();
+		if (!nested && activeCell?.interruption) throw activeCell.interruption;
+		if (nested?.signal.aborted) throw nested.signal.reason;
+		const bag = nested?.pendingTools ?? pendingTools;
 		const callId = `js-${crypto.randomUUID()}`;
-		const promise = new Promise((resolve, reject) => pendingTools.set(callId, { resolve, reject }));
+		const promise = new Promise((resolve, reject) => bag.set(callId, { resolve, reject }));
 		emit({ type: "tool-call", callId, toolName, args });
 		return await promise;
 	}
@@ -63,10 +75,16 @@ export function createWorkerCore(transport, options) {
 			pendingTools.delete(callId);
 			pending.reject(interruption);
 		}
+		kernelTools.abortAll(kernelToolError("kernel_tool_stale", interruption.message));
 		runtime.interrupt();
 	}
 
 	function onMessage(message) {
+		if (kernelTools.handle(message)) return;
+		if (message.type === "kernel-tools-names") {
+			runtime?.kernelTools.setCollisionNames(message.hostToolNames ?? [], message.foreignLanguageNames ?? []);
+			return;
+		}
 		if (message.type === "init") {
 			applySessionEnvironment(message.sessionEnv);
 			runtime = new JsWorkerRuntime({
@@ -74,6 +92,9 @@ export function createWorkerCore(transport, options) {
 				parallelPoolWidth: options.parallelPoolWidth,
 				localRoots: message.connection.localRoots,
 				artifactsDir: message.connection.artifactsDir,
+				kernelGeneration: message.kernelGeneration ?? 1,
+				hostToolNames: message.hostToolNames ?? [],
+				foreignLanguageNames: message.foreignLanguageNames ?? [],
 				onChildEvent: (event) => emit({ type: "status", event: { op: CHILD_LIFECYCLE_OP, ...event } }),
 			});
 			emit({ type: "ready" });
@@ -84,6 +105,7 @@ export function createWorkerCore(transport, options) {
 			return;
 		}
 		if (message.type === "tool-reply") {
+			if (kernelTools.settleToolReply(message)) return;
 			const pending = pendingTools.get(message.callId);
 			if (!pending) return;
 			pendingTools.delete(message.callId);
@@ -144,7 +166,7 @@ function cellInterruptedError(reason) {
 
 function bridgeError(error) {
 	if (error instanceof Error) {
-		return { name: error.name, message: error.message, stack: error.stack };
+		return { name: error.name, message: error.message, stack: error.stack, ...(typeof error.code === "string" ? { code: error.code } : {}) };
 	}
 	return { message: String(error) };
 }
@@ -153,5 +175,6 @@ function errorFromBridge(error) {
 	const result = new Error(error.message);
 	if (error.name) result.name = error.name;
 	if (error.stack) result.stack = error.stack;
+	if (typeof error.code === "string") result.code = error.code;
 	return result;
 }

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

@@ -6,6 +6,10 @@ import { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
 import { terminateProcessTrees } from "./process-tree.js";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
 import { installShellCapture } from "./worker-shell-capture.js";
+import { createWorkpool } from "./workpool.js";
+import { inKernelToolInvoke } from "./kernel-tools-context.js";
+import { kernelToolError } from "./kernel-tools-errors.js";
+import { createKernelToolRegistry, createToolNamespace } from "./kernel-tools-registry.js";
 
 const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
 // How long a child gets to honour SIGTERM before SIGKILL. Short, because the
@@ -22,6 +26,7 @@ export class JsWorkerRuntime {
 	#pendingDisplays = [];
 	#children = new Set();
 	#onChildEvent;
+	#tools;
 
 	constructor(options) {
 		this.#cwd = options.cwd;
@@ -29,9 +34,18 @@ export class JsWorkerRuntime {
 		this.#onChildEvent = typeof options.onChildEvent === "function" ? options.onChildEvent : null;
 		this.#localRoots = { ...(options.localRoots ?? {}) };
 		if (options.artifactsDir && !this.#localRoots.local) this.#localRoots.local = join(options.artifactsDir, "local");
+		this.#tools = createKernelToolRegistry({
+			generation: options.kernelGeneration ?? 1,
+			hostToolNames: options.hostToolNames ?? [],
+			foreignLanguageNames: options.foreignLanguageNames ?? [],
+		});
 		this.#installGlobals();
 	}
 
+	get kernelTools() {
+		return this.#tools;
+	}
+
 	async run(code, cellId, hooks) {
 		this.#hooks = hooks;
 		try {
@@ -107,17 +121,13 @@ export class JsWorkerRuntime {
 		globalThis.output = async (...args) => await this.#output(args);
 		globalThis.tool_schema = async name => await this.#toolSchema(name);
 		globalThis.agent = async (prompt, options, ...rest) => await this.#agent(prompt, options, rest);
+		globalThis.workpool = (agent, name, options) => createWorkpool((toolName, args) => this.#callTool(toolName, args), agent, name, options);
 		globalThis.parallel = async thunks => await this.#parallel(thunks);
 		globalThis.pipeline = async (items, ...stages) => await this.#pipeline(items, stages);
 		globalThis.completion = async (prompt, opts) => await this.#callTool("completion", { prompt, opts });
-		globalThis.tool = new Proxy(
-			{},
-			{
-				get: (_target, prop) => {
-					if (typeof prop !== "string") return undefined;
-					return async args => await this.#callTool(prop, args ?? {});
-				},
-			},
+		globalThis.tool = createToolNamespace(
+			(fn, metadata) => this.#tools.define(fn, metadata),
+			async (name, args) => await this.#callTool(name, args),
 		);
 		globalThis.tools = globalThis.tool;
 		const originalLog = console.log.bind(console);
@@ -273,6 +283,7 @@ export class JsWorkerRuntime {
 	}
 
 	async #agent(prompt, options, rest) {
+		if (inKernelToolInvoke()) throw kernelToolError("kernel_tool_recursion", "kernel tools may not invoke agent()");
 		const parsed = optionsArg({
 			name: "agent",
 			value: options,
@@ -302,6 +313,7 @@ export class JsWorkerRuntime {
 			output: text,
 			handle: details.handle ?? `agent://${id}`,
 			id,
+			run_epoch: details.run_epoch,
 			agent: details.agent ?? callArgs.agent ?? null,
 		};
 		if (Object.hasOwn(callArgs, "schema")) node.data = output;

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

@@ -39,18 +39,23 @@ export class WorkerSlot {
 		return this.#startupAbort !== null;
 	}
 
+	get generation(): number {
+		return this.#generation;
+	}
+
 	postMessage(message: HostToKernelMessage): void {
 		this.#worker?.postMessage(message);
 	}
 
 	async ensureReady(): Promise<void> {
 		if (!this.#ready) {
-			const generation = ++this.#generation;
+			const generation = this.#generation === 0 ? ++this.#generation : this.#generation;
 			const controller = new AbortController();
 			this.#startupAbort = controller;
 			const ready = startWorkerWithInlineFallback(
 				{
 					options: this.#options,
+					kernelGeneration: generation,
 					publish: (worker) => this.#publish(worker, generation),
 					isCurrent: (worker) => this.#isCurrent(worker, generation),
 					retire: (worker) => {

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

@@ -2,6 +2,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { type CodemodeRuntimeAssetEnvironment, requireCodemodeRuntimeAsset } from "../shared/runtime-asset.ts";
 import { createInlineWorker, type WorkerLike } from "./inline-worker.ts";
+import { resolveKernelToolNameSource } from "./kernel-contract.ts";
 import { type JavaScriptKernelOptions, localBridgeConnection } from "./local-module-loader.ts";
 import { spawnNodeWorker, WorkerStartupCancelledError, waitForReady } from "./worker-host.ts";
 
@@ -16,6 +17,7 @@ export function resolveJsWorkerEntryUrl(options: JavaScriptWorkerEntryUrlOptions
 
 export interface WorkerStartupHooks {
 	readonly options: JavaScriptKernelOptions;
+	readonly kernelGeneration: number;
 	/** Wires the worker into the kernel; throws `WorkerStartupCancelledError` once the generation is stale. */
 	publish(worker: WorkerLike): void;
 	isCurrent(worker: WorkerLike): boolean;
@@ -27,7 +29,7 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 	let worker = spawnWorker(hooks.options);
 	hooks.publish(worker);
 	try {
-		await initializeWorker(worker, hooks.options, signal);
+		await initializeWorker(worker, hooks, signal);
 		return;
 	} catch (error) {
 		if (!hooks.isCurrent(worker) || error instanceof WorkerStartupCancelledError) {
@@ -41,7 +43,7 @@ export async function startWorkerWithInlineFallback(hooks: WorkerStartupHooks, s
 	if (!hooks.canFallBackInline()) throw new WorkerStartupCancelledError();
 	worker = createInlineWorker(hooks.options.cwd, hooks.options.parallelPoolWidth);
 	hooks.publish(worker);
-	await initializeWorker(worker, hooks.options, signal);
+	await initializeWorker(worker, hooks, signal);
 }
 
 function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
@@ -54,16 +56,16 @@ function spawnWorker(options: JavaScriptKernelOptions): WorkerLike {
 	}
 }
 
-async function initializeWorker(
-	worker: WorkerLike,
-	options: JavaScriptKernelOptions,
-	signal: AbortSignal,
-): Promise<void> {
+async function initializeWorker(worker: WorkerLike, hooks: WorkerStartupHooks, signal: AbortSignal): Promise<void> {
 	const ready = waitForReady(worker, signal);
+	const options = hooks.options;
 	worker.postMessage({
 		type: "init",
 		sessionId: options.sessionId,
 		connection: localBridgeConnection(options),
+		kernelGeneration: hooks.kernelGeneration,
+		hostToolNames: resolveKernelToolNameSource(options.hostToolNames),
+		foreignLanguageNames: resolveKernelToolNameSource(options.foreignLanguageNames),
 		...(options.sessionEnv === undefined ? {} : { sessionEnv: options.sessionEnv }),
 	});
 	await ready;

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

@@ -0,0 +1,37 @@
+import { inKernelToolInvoke } from "./kernel-tools-context.js";
+import { kernelToolError } from "./kernel-tools-errors.js";
+
+// Only host-tool sugar: no admission, worker, or queue state belongs to the kernel.
+export async function createWorkpool(callTool, agent, name, options = {}) {
+	if (inKernelToolInvoke()) throw kernelToolError("kernel_tool_recursion", "kernel tools may not invoke workpool()");
+	if (options === null || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some(key => key !== "mode")) {
+		throw new TypeError("workpool() options only accept mode");
+	}
+	const call = async args => {
+		try {
+			return await callTool("workpool", args);
+		} catch (error) {
+			if (error?.code === "unknown_tool" || error?.code === "inactive_tool") {
+				throw workpoolError("workpool_unavailable", "No active host workpool tool", error);
+			}
+			throw error;
+		}
+	};
+	const result = await call({ op: "create", agent, name, ...options });
+	if (result.details?.error) throw workpoolError(result.details.error.code, result.details.error.message);
+	const pool_id = result.details?.pool_id;
+	if (result.hasError || typeof pool_id !== "string" || !/^wp_[0-9a-f]{32}$/.test(pool_id)) {
+		throw workpoolError("workpool_unavailable", "Host did not return a workpool identity");
+	}
+	return Object.freeze({
+		pool_id,
+		push: items => call({ op: "push", pool_id, items }),
+		close: () => call({ op: "close", pool_id }),
+		inspect: () => call({ op: "inspect", pool_id }),
+		cancel: () => call({ op: "cancel", pool_id }),
+	});
+}
+
+function workpoolError(code, message, cause) {
+	return Object.assign(new Error(message, { cause }), { code });
+}

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

@@ -0,0 +1,5 @@
+import { kernelToolError } from "./js/kernel-tools-errors.ts";
+
+export function rejectKernelToolsUnavailable(): Promise<never> {
+	return Promise.reject(kernelToolError("tools_unavailable", "Kernel tools are JavaScript-only"));
+}

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

@@ -1,4 +1,5 @@
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import type { PendingRun, PythonKernelRunOptions, PythonKernelStartOptions, ResultMessage } from "./kernel-contract.ts";
 import { failedPythonResult, PythonKernelTransport } from "./transport.ts";
 
@@ -31,6 +32,18 @@ export class PythonKernel {
 		return kernel;
 	}
 
+	listKernelToolNames(): readonly string[] {
+		return [];
+	}
+
+	describeKernelTools(_names: readonly string[]): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
+	invokeKernelTool(_request: unknown, _signal?: AbortSignal): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
 	run(input: PythonKernelRunOptions): Promise<ResultMessage> {
 		if (this.#failure) return Promise.reject(this.#failure);
 		if (this.#closed) return Promise.reject(new Error("Python kernel is closed"));

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

@@ -24,7 +24,7 @@ from collections.abc import Iterable
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from threading import Lock, Thread
-from typing import Any, Callable
+from typing import Any, Callable, Union
 from urllib.parse import unquote
 
 SESSION_ID = ""
@@ -43,7 +43,11 @@ TIMEOUT_RESUME_OP = "timeout-resume"
 
 
 class PreludeRuntimeError(RuntimeError):
-    """Host bridge or magic execution failed."""
+    """Host bridge or magic execution failed, retaining its machine code."""
+
+    def __init__(self, message: str, code: str | None = None) -> None:
+        super().__init__(message)
+        self.code = code
 
 
 class PreludeValueError(ValueError):
@@ -370,7 +374,7 @@ def bridge_post(path: str, payload: dict[str, Any]) -> Any:
         return body.get("value")
     error = body.get("error") if isinstance(body, dict) else body
     if isinstance(error, dict):
-        raise PreludeRuntimeError(str(error.get("message", error)))
+        raise PreludeRuntimeError(str(error.get("message", error)), error.get("code"))
     raise PreludeRuntimeError(str(error))
 
 
@@ -416,6 +420,54 @@ class ToolProxy:
 
 tool = ToolProxy()
 
+JsonValue = Union[str, int, float, bool, None, list["JsonValue"], dict[str, "JsonValue"]]
+
+
+def _workpool_call(args: dict[str, JsonValue]) -> dict[str, JsonValue]:
+    try:
+        return tool.workpool(args)
+    except PreludeRuntimeError as error:
+        if error.code in ("unknown_tool", "inactive_tool"):
+            raise PreludeRuntimeError("No active host workpool tool", "workpool_unavailable") from error
+        raise
+
+
+class Workpool:
+    """An opaque host identity, not a worker queue."""
+
+    __slots__ = ("pool_id",)
+
+    def __init__(self, pool_id: str) -> None:
+        self.pool_id = pool_id
+
+    def push(self, items: list[JsonValue]) -> dict[str, JsonValue]:
+        return _workpool_call({"op": "push", "pool_id": self.pool_id, "items": items})
+
+    def close(self) -> dict[str, JsonValue]:
+        return _workpool_call({"op": "close", "pool_id": self.pool_id})
+
+    def inspect(self) -> dict[str, JsonValue]:
+        return _workpool_call({"op": "inspect", "pool_id": self.pool_id})
+
+    def cancel(self) -> dict[str, JsonValue]:
+        return _workpool_call({"op": "cancel", "pool_id": self.pool_id})
+
+
+def workpool(agent: dict[str, JsonValue], name: str, *, mode: str | None = None) -> Workpool:
+    args: dict[str, JsonValue] = {"op": "create", "agent": agent, "name": name}
+    if mode is not None:
+        args["mode"] = mode
+    result = _workpool_call(args)
+    details = result.get("details")
+    if isinstance(details, dict):
+        error = details.get("error")
+        if isinstance(error, dict):
+            raise PreludeRuntimeError(str(error["message"]), str(error["code"]))
+        pool_id = details.get("pool_id")
+        if not result.get("hasError") and isinstance(pool_id, str) and re.fullmatch(r"wp_[0-9a-f]{32}", pool_id):
+            return Workpool(pool_id)
+    raise PreludeRuntimeError("Host did not return a workpool identity", "workpool_unavailable")
+
 
 def completion(
     prompt: str,
@@ -522,6 +574,7 @@ def agent(
         "output": text_value,
         "handle": handle_value,
         "id": agent_id,
+        "run_epoch": response_record.get("run_epoch"),
         "agent": response_record.get("agent", agent),
     }
     if schema is not None:
@@ -917,6 +970,7 @@ USER_NS.update(
         "tool": tool,
         "completion": completion,
         "agent": agent,
+        "workpool": workpool,
         "output": output,
         "tool_schema": tool_schema,
         "__senpi_magic": _magic,

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

@@ -140,13 +140,22 @@ def __senpi_bridge_request(path, payload)
   return body["value"] if body.is_a?(Hash) && body["ok"] == true
 
   error = body.is_a?(Hash) ? body["error"] : body
-  raise(error.is_a?(Hash) ? error["message"].to_s : error.to_s)
+  raise SenpiBridgeError.new(error.is_a?(Hash) ? error["message"].to_s : error.to_s, error.is_a?(Hash) ? error["code"] : nil)
 end
 
 def __senpi_call_tool(name, args)
   __senpi_bridge_request("/call", { "callId" => "rb-#{Process.pid}-#{rand(1_000_000)}", "toolName" => name, "args" => args })
 end
 
+class SenpiBridgeError < StandardError
+  attr_reader :code
+
+  def initialize(message, code = nil)
+    super(message)
+    @code = code
+  end
+end
+
 class SenpiToolCallable
   def initialize(name)
     @name = name
@@ -177,6 +186,8 @@ def tool
   $__senpi_tool_proxy ||= SenpiToolProxy.new
 end
 
+require_relative "workpool"
+
 def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
   options = { "model" => model }.merge(kwargs.transform_keys(&:to_s))
   options["system"] = system unless system.nil?
@@ -213,7 +224,7 @@ def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated:
   text_value = record.fetch("text", response)
   result = schema.nil? ? text_value : record.key?("data") ? record["data"] : JSON.parse(text_value.to_s)
   return result unless handle
-  { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "agent" => record.fetch("agent", agent) }.tap do |node|
+  { "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?
   end
 end

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

@@ -0,0 +1,38 @@
+# Only an opaque host identity is retained; all work remains engine-owned.
+def __senpi_workpool_call(args)
+  tool.workpool(args)
+rescue SenpiBridgeError => error
+  raise SenpiBridgeError.new("No active host workpool tool", "workpool_unavailable") if ["unknown_tool", "inactive_tool"].include?(error.code)
+  raise
+end
+
+class SenpiWorkpool
+  attr_reader :pool_id
+
+  def initialize(pool_id)
+    @pool_id = pool_id
+    freeze
+  end
+
+  def push(items)
+    __senpi_workpool_call({ "op" => "push", "pool_id" => @pool_id, "items" => items })
+  end
+
+  [:close, :inspect, :cancel].each do |op|
+    define_method(op) { __senpi_workpool_call({ "op" => op.to_s, "pool_id" => @pool_id }) }
+  end
+end
+
+def workpool(agent, name, mode: nil)
+  args = { "op" => "create", "agent" => agent, "name" => name }
+  args["mode"] = mode unless mode.nil?
+  result = __senpi_workpool_call(args)
+  details = result["details"]
+  if details.is_a?(Hash)
+    error = details["error"]
+    raise SenpiBridgeError.new(error["message"], error["code"]) if error.is_a?(Hash)
+    pool_id = details["pool_id"]
+    return SenpiWorkpool.new(pool_id) if !result["hasError"] && pool_id.is_a?(String) && /\Awp_[0-9a-f]{32}\z/.match?(pool_id)
+  end
+  raise SenpiBridgeError.new("Host did not return a workpool identity", "workpool_unavailable")
+end

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

@@ -1,6 +1,7 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import { applySessionEnvironment } from "../session-env.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
@@ -69,6 +70,18 @@ export class SubprocessKernel {
 		return { stateRetained: Promise.resolve(false) };
 	}
 
+	listKernelToolNames(): readonly string[] {
+		return [];
+	}
+
+	describeKernelTools(_names: readonly string[]): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
+	invokeKernelTool(_request: unknown, _signal?: AbortSignal): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
 	nextToolCall(): Promise<ToolCallMessage> {
 		return this.runs.nextToolCall();
 	}

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

@@ -2,6 +2,9 @@ import type { KernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelResult, KernelRunInput, ToolCallMessage } from "./subprocess-contract.ts";
 import { createPendingRun, failureResult, type PendingRun, settlePendingRun } from "./subprocess-run.ts";
 
+// Same bound as the JS kernel's pull-API fallback queue (context-manager.ts); clears happen at run teardown.
+const MAX_PENDING_TOOL_CALLS = 256;
+
 export class SubprocessRunQueue {
 	readonly #queue: PendingRun[] = [];
 	readonly #pendingCalls: ToolCallMessage[] = [];
@@ -59,7 +62,10 @@ export class SubprocessRunQueue {
 	pushToolCall(message: ToolCallMessage): void {
 		const waiter = this.#callWaiters.shift();
 		if (waiter) waiter(message);
-		else this.#pendingCalls.push(message);
+		else {
+			this.#pendingCalls.push(message);
+			if (this.#pendingCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingCalls.shift();
+		}
 	}
 
 	handleMessage(
@@ -90,6 +96,8 @@ export class SubprocessRunQueue {
 			case "ready":
 			case "init-failed":
 			case "closed":
+			case "kernel-tool-describe-reply":
+			case "kernel-tool-invoke-reply":
 				onMessage?.(message);
 				return false;
 			default: {

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

@@ -57,8 +57,10 @@ tool_schema(name?) → dict
 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
-    Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` with \`schema\`).
-{{/if}}parallel(thunks) → list
+    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.
+parallel(thunks) → list
     Thunks through a bounded pool (as wide as a \`task\` batch), input order kept; a throwing thunk propagates.
 pipeline(items, ...stages) → list
     Map items through one-arg stages with a barrier between stages; each stage receives the previous stage's result.

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

@@ -90,6 +90,8 @@ export class CellHandler {
 			case "init-failed":
 			case "result":
 			case "closed":
+			case "kernel-tool-describe-reply":
+			case "kernel-tool-invoke-reply":
 				return;
 			default:
 				throw new TypeError(`Unhandled kernel message: ${String(message)}`);
@@ -223,7 +225,12 @@ export class CellHandler {
 				type: "tool-reply",
 				callId: message.callId,
 				ok: false,
-				error: { message: text },
+				error: {
+					message: text,
+					...(error instanceof Error && "code" in error && typeof error.code === "string"
+						? { code: error.code }
+						: {}),
+				},
 			});
 		}
 		this.#resultBuilder.emitUpdate(false);