@code-yeongyu/senpi 2026.9.15-2 → 2026.9.16

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-schema.js

@@ -0,0 +1,69 @@
+import { kernelToolError } from "./kernel-tools-errors.js";
+
+export function defaultInputSchema(params) {
+	return {
+		type: "object",
+		properties: Object.fromEntries(params.map((name) => [name, {}])),
+		required: [...params],
+		additionalProperties: false,
+	};
+}
+
+export function resolveToolMetadata(metadata, params) {
+	if (metadata === undefined) return { description: "", input_schema: defaultInputSchema(params) };
+	if (!isPlainJsonObject(metadata)) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata must be plain JSON");
+	}
+	const description = metadata.description === undefined ? "" : metadata.description;
+	if (typeof description !== "string") {
+		throw kernelToolError("invalid_tool_definition", "tool() description must be a string");
+	}
+	if (metadata.schema === undefined) return { description, input_schema: defaultInputSchema(params) };
+	const schema = metadata.schema;
+	if (!isPlainJsonObject(schema) || schema.type !== "object" || !isPlainJsonObject(schema.properties)) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata schema must be a JSON object schema");
+	}
+	const propertyKeys = Object.keys(schema.properties);
+	if (propertyKeys.length !== params.length || params.some((name) => !Object.hasOwn(schema.properties, name))) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata schema properties must match parameters");
+	}
+	return { description, input_schema: schema };
+}
+
+export function validateInvokeArgs(schema, args) {
+	if (!isPlainJsonObject(args)) throw kernelToolError("invalid_tool_definition", "kernel tool args must be a JSON object");
+	const required = Array.isArray(schema.required) ? schema.required : [];
+	for (const key of required) {
+		if (!Object.hasOwn(args, key)) {
+			throw kernelToolError("invalid_tool_definition", `missing kernel tool argument: ${key}`);
+		}
+	}
+	if (schema.additionalProperties === false) {
+		const allowed = new Set(Object.keys(schema.properties ?? {}));
+		for (const key of Object.keys(args)) {
+			if (!allowed.has(key)) {
+				throw kernelToolError("invalid_tool_definition", `unexpected kernel tool argument: ${key}`);
+			}
+		}
+	}
+}
+
+export function isPlainJsonObject(value) {
+	return isJsonValue(value) && value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function isJsonValue(value) {
+	if (value === null) return true;
+	const type = typeof value;
+	if (type === "string" || type === "boolean") return true;
+	if (type === "number") return Number.isFinite(value);
+	if (type !== "object") return false;
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return Object.values(value).every(isJsonValue);
+}
+
+export function orderedArgs(params, args) {
+	return params.map((name) => args[name]);
+}

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

@@ -0,0 +1,42 @@
+import type { KernelToolErrorCode } from "./kernel-tools-errors.ts";
+
+export type { KernelToolErrorCode };
+
+export type KernelToolDescriptor = {
+	readonly name: string;
+	readonly description: string;
+	readonly input_schema: unknown;
+	readonly language: "js";
+	readonly kernel_generation: number;
+	readonly definition_revision: number;
+};
+
+export type KernelToolsInvokeRequest = {
+	readonly name: string;
+	readonly kernel_generation: number;
+	readonly definition_revision: number;
+	readonly args: unknown;
+	readonly call_id: string;
+};
+
+export type KernelToolsDescribeEntry =
+	| { readonly name: string; readonly ok: true; readonly descriptor: KernelToolDescriptor }
+	| {
+			readonly name: string;
+			readonly ok: false;
+			readonly error: { readonly code: KernelToolErrorCode; readonly message: string };
+	  };
+
+export type KernelToolsDescribeResult = {
+	readonly results: readonly KernelToolsDescribeEntry[];
+};
+
+export type KernelToolsCapability = {
+	describe(names: readonly string[]): Promise<KernelToolsDescribeResult>;
+	invoke(request: KernelToolsInvokeRequest, signal?: AbortSignal): Promise<unknown>;
+};
+
+export const KERNEL_TOOLS_UNSUPPORTED = {
+	code: "tools_unavailable" as const,
+	message: "Kernel tools require a live JavaScript worker context",
+};

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

@@ -7,9 +7,11 @@ export const JAVASCRIPT_KERNEL_PRELUDE = [
 	"read(path, options?): read UTF-8 text; plain paths use cwd and local:// uses the session local root.",
 	"write(path, content): write UTF-8 or binary data and return the resolved path.",
 	"tool.<name>(args): request a host tool call through the bridge; resolves to { text, images?, details?, hasError? }.",
+	"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.",
+	"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.",
 ].join("\n");

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

@@ -96,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: {