@code-yeongyu/senpi 2026.9.15 → 2026.9.16-2

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

@@ -12,6 +12,56 @@
 
 ### Removed
 
+## [2026.9.16-2] - 2026-09-16
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- The JavaScript kernel-tool capability now reaches host tools called from inside a running eval cell. A cell that registers `tool(fn)` can hand those functions to its in-process children through `task`/`agent`/`workpool`, because `ExtensionContext.kernelTools` resolves for the duration of each host tool call the cell makes. It was undefined at the dispatch point — the worker's message loop ran outside the `kernelToolsStorage` scope that only covered the awaited run chain — so every grant was refused with `tools_unavailable` and the capability shipped in the previous release could not be used ([#1754](https://github.com/code-yeongyu/senpi/issues/1754)).
+
+### Removed
+
+## [2026.9.16] - 2026-09-16
+
+### Breaking Changes
+
+- Background `agent(..., handle=true)` now requires the host task tool to return structured `details.task_id` (`st_` plus lowercase hex) and an integer `details.run_epoch >= 0`. The result gains a `run_epoch` field next to `id` and `handle`, in every kernel language. A host that returns an error, or only a prose task id in its text, raises `invalid_task_handle`; the old regex scrape of the text is gone. Extra producer fields in `details` are accepted. Foreground text and JSON results are unchanged ([#1646](https://github.com/code-yeongyu/senpi/issues/1646)).
+
+### Added
+
+- Added `workpool(agent, name, mode?)` to the JS, Python, Ruby and Julia preludes as a thin adapter over the host `workpool` tool. `agent` is a plain-data spec with one of `category` or `subagent_type` plus `prompt` and optional `model`; `mode` is `fresh` or `keep_alive` and is forwarded only when given. The adapter exposes `pool_id`, `push(items)`, `close()`, `inspect()` and `cancel()`, each returning the same `{text, details, images?, hasError?}` envelope as a direct tool call, and holds no worker, queue or admission state, so a kernel reset drops only the variable and the pool survives. A missing or inactive host tool raises `workpool_unavailable`; a host error at creation is raised instead of returning a broken adapter. Kernel tools may not call `workpool()` (`kernel_tool_recursion`) ([#1646](https://github.com/code-yeongyu/senpi/issues/1646)).
+- Added JavaScript kernel tools. `tool(fn, metadata?)` registers a named `function` or `async function` declaration as a fenced tool for in-process children while `tool.<name>(args)` host calls keep working. The parser reads only the declaration head: anonymous functions, classes, generators, native functions and non-identifier parameters are rejected with `invalid_tool_definition`; unicode identifiers are kept as written. Names must already fit the MCP grammar (`[A-Za-z0-9_-]`, at most 64 characters) and are checked against reserved bridge names, live host tools (including tools attached after the worker started) and tools registered by the session's Python, Ruby or Julia kernels, raising `reserved_tool_name` or `tool_name_collision`. Each descriptor carries `name`, a JSON input schema, `kernel_generation` and `definition_revision`; a stale generation or revision is refused with `kernel_tool_stale`, redefining a function bumps its revision, and a kernel reset clears every registered tool and bumps the generation. `agent()` accepts `tools: string[]` to hand a child those tool names. Kernel-tool requests against Python, Ruby or Julia kernels fail with `tools_unavailable` ([#1647](https://github.com/code-yeongyu/senpi/issues/1647)).
+- The JS worker answers kernel-tool `describe` and `invoke` requests on a separate pump from the top-level run queue, so a parent cell can stay pending on `agent()` while an in-process child calls one of the parent's registered functions. Interrupting the parent settles every nested invoke, and a worker reset, crash or close rejects the pending ones with `kernel_tool_stale` ([#1647](https://github.com/code-yeongyu/senpi/issues/1647)).
+- `CodemodeExtensionAPI.kernelTools` exposes the parent cell's kernel-tool `describe`/`invoke` capability to extensions while a JavaScript eval is live; `KernelToolDescriptor`, `KernelToolsCapability`, `KernelToolsDescribeResult`, `KernelToolsInvokeRequest` and `KERNEL_TOOLS_UNSUPPORTED` are exported. Kernels may implement `EvalKernel.listKernelToolNames()` so the session manager can detect cross-language name collisions ([#1647](https://github.com/code-yeongyu/senpi/issues/1647)).
+
+### Changed
+
+- The eval prompt documents `workpool()` and the `run_epoch` field on background `agent()` handles, and the JS prelude describes `tool(fn, metadata?)` and `workpool()` ([#1646](https://github.com/code-yeongyu/senpi/issues/1646), [#1647](https://github.com/code-yeongyu/senpi/issues/1647)).
+
+### Fixed
+
+### Removed
+
+## [2026.9.15-2] - 2026-09-15
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Detached eval result cards no longer arm the 1 Hz repaint ticker (they render static with frozen elapsed time), and a live ticker whose row stops rendering now stops itself after 60 idle ticks and rearms on the next render, so transcript rebuilds and session switches cannot accumulate intervals on idle sessions ([#1696](https://github.com/code-yeongyu/senpi/issues/1696)).
+- Bounded three unbounded retentions that grew long-lived session heaps without limit: settled eval cells now leave the live registry into a 32-entry terminal snapshot LRU, the JS kernel's unconsumed tool-call queue is capped at 256 and cleared on interrupt/reset/close/crash (mirroring the subprocess kernel), and per-cell display buffers cap at 8 images / 24 MB / 64 JSON outputs with elision notes ([#1695](https://github.com/code-yeongyu/senpi/issues/1695)).
+
+### Removed
+
 ## [2026.9.15] - 2026-09-15
 
 ### Breaking Changes

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

@@ -144,6 +144,7 @@ options object and asynchronous helpers are `await`-able.
 | `tool_schema(name?)` | Returns a tool's parameter schema without calling it; omit `name` to list tool names. |
 | `completion(prompt, model?, system?, schema?)` | Requests a one-shot host completion; `schema` asks the host to parse structured output. |
 | `agent(prompt, ...)` | Delegates to the configured active `taskTools.task` tool. Supports background handles and structured JSON results. |
+| `workpool(agent, name, mode?)` | Creates a thin adapter over the normal host `workpool` tool; exposes `pool_id`, `push(items)`, `close()`, `inspect()`, and `cancel()`. JS awaits creation and operations. |
 | `output(ids, format?, offset?, limit?)` | Delegates transcript retrieval to the configured active `taskTools.output` tool. |
 | `parallel(thunks)` | Runs thunks through the configured bounded pool while preserving input order. |
 | `pipeline(items, ...stages)` | Applies stages left to right with a barrier between stages. |
@@ -164,6 +165,29 @@ 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.
 
+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.
+
+`workpool` takes exactly one of `{category, prompt, model?}` or
+`{subagent_type, prompt, model?}` as its plain-data agent spec. Mode is `fresh`
+or `keep_alive`: pass `{mode: "fresh"}` in JS, `mode="fresh"` in Python/Julia,
+or `mode: "fresh"` in Ruby. Omission is forwarded unchanged to the engine;
+hosts without an approved default still require an explicit mode. Custom tool
+names are not enabled by this adapter.
+
+`push` forwards `[{key, input}]` and returns the host receipt without waiting
+for admission. Operations return the same `{text, details, images?, hasError?}`
+envelope as direct tool calls. Creation refuses host errors instead of returning
+a broken adapter; a missing host raises `workpool_unavailable`. The host owns
+workers, keyed yields, cancellation, and aggregate delivery after explicit
+`close()`; none is implemented in a kernel. Aggregate support requires a host
+that implements it. Reset only removes kernel variables: save `pool_id` and use
+`tool.workpool({op: "inspect", pool_id})` from a new JS cell (equivalent keyword
+arguments in other languages). An open pool's adapter can be recreated with the
+same name/spec/mode; no worker state is reconstructed in the prelude.
+
 ## Required summary
 
 Every `eval` run call MUST include a `summary` — one line in the user's

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.15",
+	"version": "2026.9.16-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.15",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.16-2",
 		"typebox": "1.3.27"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.15"
+		"@code-yeongyu/senpi": "2026.9.16-2"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.15"
+		"@code-yeongyu/senpi": "2026.9.16-2"
 	},
 	"keywords": [
 		"senpi",

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/http-server.ts

@@ -217,7 +217,13 @@ function sendJson(response: ServerResponse, status: number, body: JsonReply): vo
 }
 
 function bridgeError(error: unknown): BridgeError {
-	if (error instanceof Error) return { name: error.name, message: error.message, stack: error.stack };
+	if (error instanceof Error)
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			...("code" in error && typeof error.code === "string" ? { code: error.code } : {}),
+		};
 	return { message: String(error) };
 }
 

package/node_modules/@code-yeongyu/senpi-codemode/src/bridge/kernel-tools-protocol.ts

@@ -0,0 +1,85 @@
+import { type Static, Type } from "typebox";
+
+const kernelToolErrorSchema = Type.Object({
+	message: Type.String(),
+	name: Type.Optional(Type.String()),
+	stack: Type.Optional(Type.String()),
+	code: Type.Optional(Type.String()),
+});
+
+export const kernelToolDescriptorSchema = Type.Object({
+	name: Type.String({ minLength: 1 }),
+	description: Type.String(),
+	input_schema: Type.Unknown(),
+	language: Type.Literal("js"),
+	kernel_generation: Type.Integer({ minimum: 0 }),
+	definition_revision: Type.Integer({ minimum: 1 }),
+});
+
+const describeResultSchema = Type.Union([
+	Type.Object({
+		name: Type.String({ minLength: 1 }),
+		ok: Type.Literal(true),
+		descriptor: kernelToolDescriptorSchema,
+	}),
+	Type.Object({
+		name: Type.String({ minLength: 1 }),
+		ok: Type.Literal(false),
+		error: kernelToolErrorSchema,
+	}),
+]);
+
+export const kernelToolHostToKernelSchemas = [
+	Type.Object({
+		type: Type.Literal("kernel-tool-describe"),
+		requestId: Type.String({ minLength: 1 }),
+		names: Type.Array(Type.String({ minLength: 1 })),
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tool-invoke"),
+		requestId: Type.String({ minLength: 1 }),
+		name: Type.String({ minLength: 1 }),
+		kernel_generation: Type.Integer({ minimum: 0 }),
+		definition_revision: Type.Integer({ minimum: 1 }),
+		args: Type.Unknown(),
+		call_id: Type.String({ minLength: 1 }),
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tool-cancel"),
+		requestId: Type.String({ minLength: 1 }),
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tools-names"),
+		hostToolNames: Type.Array(Type.String({ minLength: 1 })),
+		foreignLanguageNames: Type.Array(Type.String({ minLength: 1 })),
+	}),
+] as const;
+
+export const kernelToolKernelToHostSchemas = [
+	Type.Object({
+		type: Type.Literal("kernel-tool-describe-reply"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(true),
+		results: Type.Array(describeResultSchema),
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tool-describe-reply"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(false),
+		error: kernelToolErrorSchema,
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tool-invoke-reply"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(true),
+		value: Type.Unknown(),
+	}),
+	Type.Object({
+		type: Type.Literal("kernel-tool-invoke-reply"),
+		requestId: Type.String({ minLength: 1 }),
+		ok: Type.Literal(false),
+		error: kernelToolErrorSchema,
+	}),
+] as const;
+
+export type KernelToolDescriptorMessage = Static<typeof kernelToolDescriptorSchema>;

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

@@ -1,6 +1,7 @@
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
+import { kernelToolHostToKernelSchemas, kernelToolKernelToHostSchemas } from "./kernel-tools-protocol.ts";
 
 export const BRIDGE_FRAME_MAX_BYTES = 10 * 1024 * 1024;
 
@@ -27,6 +28,9 @@ const hostToKernelMessageSchema = Type.Union([
 		sessionId: Type.String({ minLength: 1 }),
 		connection: connectionConfigSchema,
 		sessionEnv: Type.Optional(Type.Record(Type.String(), Type.String())),
+		kernelGeneration: Type.Optional(Type.Integer({ minimum: 1 })),
+		hostToolNames: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+		foreignLanguageNames: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
 	}),
 	Type.Object({
 		type: Type.Literal("run"),
@@ -53,6 +57,7 @@ const hostToKernelMessageSchema = Type.Union([
 	Type.Object({
 		type: Type.Literal("close"),
 	}),
+	...kernelToolHostToKernelSchemas,
 ]);
 
 const kernelToHostMessageSchema = Type.Union([
@@ -92,6 +97,7 @@ const kernelToHostMessageSchema = Type.Union([
 		durationMs: Type.Integer({ minimum: 0 }),
 	}),
 	Type.Object({ type: Type.Literal("closed") }),
+	...kernelToolKernelToHostSchemas,
 ]);
 
 const bridgeMessageSchema = Type.Union([hostToKernelMessageSchema, kernelToHostMessageSchema]);

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

@@ -11,6 +11,7 @@ const agentArgsSchema = Type.Object(
 		label: Type.Optional(Type.String()),
 		schema: Type.Optional(Type.Unknown()),
 		handle: Type.Optional(Type.Boolean()),
+		tools: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
 		isolated: Type.Optional(Type.Boolean()),
 		apply: Type.Optional(Type.Boolean()),
 		merge: Type.Optional(Type.Boolean()),
@@ -19,7 +20,19 @@ const agentArgsSchema = Type.Object(
 );
 
 const unsupportedIsolationWarning = "isolated/apply/merge unsupported (no isolation in task engine)";
-const taskIdPattern = /\bst_[A-Za-z0-9_-]+\b/;
+const taskHandleSchema = Type.Object(
+	{
+		task_id: Type.String({ pattern: "^st_[0-9a-f]+$" }),
+		run_epoch: Type.Integer({ minimum: 0 }),
+	},
+	{ additionalProperties: true },
+);
+
+/** Structural host contract; no orchestration package dependency. */
+export type TaskHandleDetails = {
+	readonly task_id: string;
+	readonly run_epoch: number;
+};
 const droppedOptionNames = ["isolated", "apply", "merge"] as const;
 
 type AgentArgs = Static<typeof agentArgsSchema>;
@@ -29,6 +42,7 @@ type TaskParams = {
 	readonly model?: string;
 	readonly name?: string;
 	readonly run_in_background: boolean;
+	readonly tools?: readonly string[];
 };
 type ProgressContext = { readonly fallbackId: string; readonly warning?: string };
 
@@ -48,7 +62,7 @@ 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 text: string; readonly id: string; readonly handle: string; readonly run_epoch: number };
 
 class AgentArgumentsError extends Error {
 	readonly name = "AgentArgumentsError";
@@ -68,9 +82,10 @@ class AgentUnavailableError extends Error {
 
 class AgentHandleError extends Error {
 	readonly name = "AgentHandleError";
+	readonly code = "invalid_task_handle";
 
 	constructor() {
-		super("agent() background task result did not include a task id");
+		super("agent() requires successful task details with a valid task_id and nonnegative integer run_epoch");
 	}
 }
 
@@ -105,9 +120,8 @@ export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions):
 
 	const text = resultText(result);
 	if (parsed.handle === true) {
-		const id = resultTaskId(result, text);
-		if (!id) throw new AgentHandleError();
-		return { text, id, handle: `agent://${id}` };
+		const { task_id: id, run_epoch } = resultTaskHandle(result);
+		return { text, id, handle: `agent://${id}`, run_epoch };
 	}
 	if (!structured) return { text };
 	return parseStructuredText(text);
@@ -130,6 +144,7 @@ function toTaskParams(args: AgentArgs, structured: boolean): TaskParams {
 		...(args.model === undefined ? {} : { model: args.model }),
 		...(args.label === undefined ? {} : { name: args.label }),
 		run_in_background: args.handle === true,
+		...(args.tools === undefined ? {} : { tools: args.tools }),
 	};
 }
 
@@ -168,11 +183,15 @@ function resultText(result: AgentToolResult<unknown>): string {
 		.join("\n");
 }
 
-function resultTaskId(result: AgentToolResult<unknown>, text: string): string | undefined {
-	const details = isRecord(result.details) ? result.details : undefined;
-	const detailId = firstString(details, ["task_id", "taskId", "id"]);
-	if (detailId) return detailId;
-	return text.match(taskIdPattern)?.[0];
+function resultTaskHandle(result: AgentToolResult<unknown>): TaskHandleDetails {
+	const details = result.details;
+	if (
+		("isError" in result && result.isError === true) ||
+		(isRecord(details) && (details.isError === true || details.error !== undefined)) ||
+		!Check(taskHandleSchema, details)
+	)
+		throw new AgentHandleError();
+	return details;
 }
 
 function firstString(

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/session-manager.ts

@@ -215,6 +215,8 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 				cwd: this.#options.cwd,
 				parallelPoolWidth,
 				onMessage,
+				hostToolNames: () => this.#options.listTools?.().map((tool) => tool.name) ?? [],
+				foreignLanguageNames: () => this.#foreignKernelToolNames(),
 				...(this.#options.sessionEnv ? { sessionEnv: this.#options.sessionEnv } : {}),
 				...(localRoots ? { localRoots: { ...localRoots } } : {}),
 				...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
@@ -259,6 +261,15 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 		});
 	}
 
+	#foreignKernelToolNames(): string[] {
+		const names: string[] = [];
+		for (const [language, kernel] of this.#kernels) {
+			if (language === "js") continue;
+			names.push(...(kernel.listKernelToolNames?.() ?? []));
+		}
+		return names;
+	}
+
 	#contextFor(signal: AbortSignal): ExtensionContext {
 		const ctx = this.#context;
 		if (!ctx) throw new CodemodeContextUnavailableError();

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

@@ -23,6 +23,7 @@ import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
 import { activeBunSkillPath, registerBunSkillContribution } from "./extension/skill-contribution.ts";
 import { WAKE_SOURCE_STATE_EVENT, type WakeSourceState } from "./extension/wake-source-state.ts";
+import type { KernelToolsCapability } from "./kernels/js/kernel-tools-types.ts";
 import { EvalDetachedCellManager, type EvalDetachedCellStatusEntry } from "./tool/detached-cell-manager.ts";
 import {
 	EVAL_EXECUTION_EVENT,
@@ -48,6 +49,8 @@ export interface CodemodeExtensionAPI {
 	registerRemovedToolHint(name: string, hint: string): void;
 	on(event: CodemodeEvent | "resources_discover", handler: (event: unknown, ctx: ExtensionContext) => unknown): void;
 	executeTool: AgentExecuteTool;
+	/** Present only while a live JavaScript eval owns the host-tool context. */
+	kernelTools?: KernelToolsCapability;
 	getActiveTools(): string[];
 	getAllTools(): readonly EvalSchemaToolInfo[];
 	sendMessage(
@@ -259,4 +262,11 @@ function modelIdFrom(event: unknown): string | undefined {
 	return typeof model.id === "string" ? model.id : undefined;
 }
 
+export {
+	KERNEL_TOOLS_UNSUPPORTED,
+	type KernelToolDescriptor,
+	type KernelToolsCapability,
+	type KernelToolsDescribeResult,
+	type KernelToolsInvokeRequest,
+} from "./kernels/js/kernel-tools-types.ts";
 export { enabledLanguagesFrom };

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

@@ -181,6 +181,51 @@ end
 Base.getproperty(::SenpiToolProxy, name::Symbol) = SenpiToolCallable(string(name))
 const tool = SenpiToolProxy()
 
+struct SenpiBridgeError <: Exception
+    message::String
+    code::Union{String, Nothing}
+end
+Base.showerror(io::IO, error::SenpiBridgeError) = Base.print(io, error.message)
+
+function senpi_workpool_call(args)
+    try
+        return tool.workpool(args)
+    catch error
+        if error isa SenpiBridgeError && error.code in ("unknown_tool", "inactive_tool")
+            throw(SenpiBridgeError("No active host workpool tool", "workpool_unavailable"))
+        end
+        rethrow()
+    end
+end
+
+struct SenpiWorkpool
+    pool_id::String
+end
+
+function Base.getproperty(pool::SenpiWorkpool, name::Symbol)
+    pool_id = getfield(pool, :pool_id)
+    name === :pool_id && return pool_id
+    name === :push && return items -> senpi_workpool_call(Dict("op" => "push", "pool_id" => pool_id, "items" => items))
+    name in (:close, :inspect, :cancel) && return () -> senpi_workpool_call(Dict("op" => string(name), "pool_id" => pool_id))
+    getfield(pool, name)
+end
+
+function workpool(agent::AbstractDict, name::AbstractString; mode=nothing)
+    args = Dict{String, Any}("op" => "create", "agent" => agent, "name" => name)
+    mode !== nothing && (args["mode"] = mode)
+    result = senpi_workpool_call(args)
+    details = get(result, "details", nothing)
+    if details isa AbstractDict
+        error = get(details, "error", nothing)
+        error isa AbstractDict && throw(SenpiBridgeError(error["message"], error["code"]))
+        pool_id = get(details, "pool_id", nothing)
+        if get(result, "hasError", false) !== true && pool_id isa AbstractString && occursin(r"^wp_[0-9a-f]{32}$", pool_id)
+            return SenpiWorkpool(pool_id)
+        end
+    end
+    throw(SenpiBridgeError("Host did not return a workpool identity", "workpool_unavailable"))
+end
+
 function completion(prompt::AbstractString; model="default", system=nothing, schema=nothing, kwargs...)
     options = Dict{String, Any}("model" => model)
     system !== nothing && (options["system"] = system)
@@ -225,6 +270,7 @@ function agent(prompt::AbstractString; agent="task", model=nothing, label=nothin
     handle || return parsed
     result = Dict{String, Any}("text" => text_value, "output" => text_value, "id" => get(record, "id", nothing), "agent" => get(record, "agent", agent))
     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)
     result
 end

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

@@ -244,7 +244,7 @@ function senpi_bridge_request(path::String, payload)
         parsed isa AbstractDict || error("Bridge returned invalid JSON")
         get(parsed, "ok", false) === true && return get(parsed, "value", nothing)
         failure = get(parsed, "error", parsed)
-        error(failure isa AbstractDict ? string(get(failure, "message", failure)) : string(failure))
+        throw(SenpiBridgeError(failure isa AbstractDict ? string(get(failure, "message", failure)) : string(failure), failure isa AbstractDict ? get(failure, "code", nothing) : nothing))
     finally
         close(socket)
     end

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

@@ -8,8 +8,12 @@ import {
 	type JavaScriptRunInput,
 	type LifecycleState,
 	type ResultMessage,
+	resolveKernelToolNameSource,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
+import { kernelToolError } from "./kernel-tools-errors.ts";
+import { KernelToolHostPump } from "./kernel-tools-host.ts";
+import type { KernelToolsDescribeResult, KernelToolsInvokeRequest } from "./kernel-tools-types.ts";
 import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
 import { terminateProcessTrees } from "./process-tree-host.ts";
 import { JavaScriptRunQueue, type PendingJavaScriptRun, stoppedResult } from "./run-queue.ts";
@@ -23,6 +27,10 @@ export { type JavaScriptWorkerEntryUrlOptions, resolveJsWorkerEntryUrl } from ".
 /** How long a lost worker's children get to honour SIGTERM before the host sends SIGKILL. */
 const WORKER_LOSS_CHILD_GRACE_MS = 1_000;
 
+// Pull-API fallback queue bound: a nextToolCall consumer this far behind is already stalled, and the
+// normal push path (onMessage) never reads the queue, so unbounded growth only pins tool args (#1695).
+const MAX_PENDING_TOOL_CALLS = 256;
+
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
@@ -32,6 +40,10 @@ export class JavaScriptKernel {
 	#recovery: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
 	readonly #runs = new JavaScriptRunQueue();
+	readonly #kernelTools = new KernelToolHostPump(
+		(message) => this.#slot.postMessage(message),
+		() => this.#lifecycle === "open" && this.#slot.present,
+	);
 	#timeout: NodeJS.Timeout | null = null;
 	#toolWaiters: Array<(message: ToolCallMessage) => void> = [];
 	#pendingToolCalls: ToolCallMessage[] = [];
@@ -52,6 +64,18 @@ export class JavaScriptKernel {
 		return this.#slot.mode;
 	}
 
+	get kernelToolEvents(): EventTarget {
+		return this.#kernelTools.events;
+	}
+
+	describeKernelTools(names: readonly string[]): Promise<KernelToolsDescribeResult> {
+		return this.#kernelTools.describe(names);
+	}
+
+	invokeKernelTool(request: KernelToolsInvokeRequest, signal?: AbortSignal): Promise<unknown> {
+		return this.#kernelTools.invoke(request, signal);
+	}
+
 	async run(input: JavaScriptRunInput): Promise<ResultMessage> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
 		const promise = this.#runs.enqueue(input);
@@ -77,6 +101,7 @@ export class JavaScriptKernel {
 	async reset(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#terminate();
+		this.#clearToolCalls();
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#ensureReady();
 		this.#startNext();
@@ -97,6 +122,8 @@ export class JavaScriptKernel {
 		this.#slot.postMessage({ type: "close" });
 		this.#lifecycle = "closing";
 		this.#runs.settleAll("JS kernel closed");
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JS kernel closed"));
+		this.#clearToolCalls();
 		const recovery = this.#recovery;
 		const closePromise = (async () => {
 			if (recovery) await recovery;
@@ -140,6 +167,11 @@ export class JavaScriptKernel {
 		if (next.input.timeoutMs) {
 			this.#timeout = setTimeout(() => void this.#timeoutActive(next), next.input.timeoutMs);
 		}
+		this.#slot.postMessage({
+			type: "kernel-tools-names",
+			hostToolNames: resolveKernelToolNameSource(this.#options.hostToolNames),
+			foreignLanguageNames: resolveKernelToolNameSource(this.#options.foreignLanguageNames),
+		});
 		this.#slot.postMessage({
 			type: "run",
 			cellId: next.input.cellId,
@@ -170,15 +202,19 @@ export class JavaScriptKernel {
 		message: string,
 		durationMs = 0,
 	): Promise<{ readonly retained: boolean; readonly note?: string }> {
-		run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
-		run.interruptAck ??= Promise.withResolvers<void>();
-		this.#slot.postMessage({ type: "interrupt", reason });
-		if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
-		if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
-		const retirement = await this.#terminate();
-		this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
-		void this.#recover(() => Promise.resolve());
-		return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		try {
+			run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
+			run.interruptAck ??= Promise.withResolvers<void>();
+			this.#slot.postMessage({ type: "interrupt", reason });
+			if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
+			if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
+			const retirement = await this.#terminate();
+			this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
+			void this.#recover(() => Promise.resolve());
+			return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		} finally {
+			this.#clearToolCalls();
+		}
 	}
 
 	async #restartAfterStop(): Promise<void> {
@@ -210,6 +246,7 @@ export class JavaScriptKernel {
 	}
 
 	#handleMessage(message: KernelToHostMessage): void {
+		if (this.#kernelTools.consume(message) && message.type !== "tool-call") return;
 		if (message.type === "status" && message.event.op === INTERRUPT_ACK_OP) {
 			this.#runs.active?.interruptAck?.resolve();
 			return;
@@ -223,7 +260,10 @@ export class JavaScriptKernel {
 		if (message.type === "tool-call") {
 			const waiter = this.#toolWaiters.shift();
 			if (waiter) waiter(message);
-			else this.#pendingToolCalls.push(message);
+			else {
+				this.#pendingToolCalls.push(message);
+				if (this.#pendingToolCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingToolCalls.shift();
+			}
 			return;
 		}
 		if (message.type !== "result") return;
@@ -240,6 +280,7 @@ export class JavaScriptKernel {
 		const active = this.#runs.active;
 		if (!active && this.#slot.startingUp) return;
 		this.#clearTimeout();
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", error.message));
 		if (active) {
 			this.#runs.releaseActive(active);
 			this.#runs.settle(active, {
@@ -250,9 +291,15 @@ export class JavaScriptKernel {
 				durationMs: this.#runs.durationMs(active, performance.now()),
 			});
 		}
+		this.#clearToolCalls();
 		void this.#restartAfterStop();
 	}
 
+	#clearToolCalls(): void {
+		this.#pendingToolCalls.length = 0;
+		this.#toolWaiters.length = 0;
+	}
+
 	#clearTimeout(): void {
 		if (this.#timeout) clearTimeout(this.#timeout);
 		this.#timeout = null;
@@ -271,6 +318,7 @@ export class JavaScriptKernel {
 	 */
 	async #terminate(): Promise<WorkerRetirement> {
 		this.#clearTimeout();
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JavaScript worker reset"));
 		const retirement = await this.#slot.retire();
 		await this.#retireWorkerChildren();
 		return retirement;