@code-yeongyu/senpi-codemode 2026.9.2 → 2026.9.3-3

package/CHANGELOG.md

@@ -12,6 +12,89 @@
 
 ### Removed
 
+## [2026.9.3-3] - 2026-09-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.3-2] - 2026-09-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- JavaScript eval cells no longer leak child-process output onto the host terminal under Bun: `Bun.$` commands awaited without `.quiet()`/`.text()` and `Bun.spawn` children with the default stderr now route their output into the cell's stdout/stderr streams instead of the inherited fd 1/2 that the interactive TUI owns.
+
+### Removed
+
+## [2026.9.3] - 2026-09-03
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.2-4] - 2026-09-02
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.2-3] - 2026-09-02
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- The eval prompt's JS runtime line is now runtime-aware: on a bun kernel it names `Bun <version>` and
+  `Bun.*` builtins, and only while the bundled `bun-1-4` skill is active it adds a MUST READ pointer to
+  that skill's absolute path before the first js cell; node kernels keep the Node.js worker wording.
+  `activeBunSkillPath()` exposes the same gate the `resources_discover` contribution uses.
+- The bundled `bun-1-4` skill description is rewritten as a fact-framed MUST READ notice with
+  English-only copy (Korean trigger words removed; the `Bun.stringWidth` example no longer uses Hangul).
+
+### Fixed
+
+- Compiled binaries now contribute the bundled `bun-1-4` skill by resolving the codemode sidecar shipped next to the executable, and a missing skill is reported on stderr so it can no longer corrupt the RPC protocol stream on stdout.
+
+### Removed
+
+## [2026.9.2-2] - 2026-09-02
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
 ## [2026.9.2] - 2026-09-02
 
 ### Breaking Changes

package/README.md

@@ -36,7 +36,9 @@ task-tool names are known.
   resolves absolute executable paths, and the eval prompt host line names the
   JS runtime (`node`/`bun`).
 - JavaScript import rewriting for supported local modules and package imports
-  in the persistent Node.js worker.
+  in the persistent JS worker (Bun when senpi runs on bun, Node.js otherwise).
+- On a Bun >= 1.4 kernel the eval prompt names the bundled `bun-1-4` skill as
+  MUST READ before the first js cell; node kernels keep the Node.js wording.
 - GPT models receive a terse `eval` prompt dialect that prioritizes composing
   active tools through `tool.<name>(args)` and documents detach-on-timeout.
 
@@ -44,7 +46,7 @@ task-tool names are known.
 
 | Language | Default | Runtime | Notes |
 | --- | --- | --- | --- |
-| `js` | enabled | Node.js worker | Requires Node.js 24 or newer; supports top-level `await` and `return`. |
+| `js` | enabled | In-process worker on senpi's own runtime (Bun or Node.js 24+) | Supports top-level `await` and `return`; the eval prompt's runtime line follows the kernel. |
 | `py` | enabled | `python3` or `python` | Optional interpreter detected at session start. |
 | `rb` | disabled | `ruby` | Optional interpreter detected at session start. |
 | `jl` | disabled | `julia` | Optional interpreter detected at session start. |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.2",
+	"version": "2026.9.3-3",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.3-3",
 		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.2"
+		"@code-yeongyu/senpi": "2026.9.3-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.2"
+		"@code-yeongyu/senpi": "2026.9.3-3"
 	},
 	"keywords": [
 		"senpi",

package/src/extension/skill-contribution.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { type CodemodeRuntimeAssetEnvironment, resolveCodemodeRuntimeAsset } from "../kernels/shared/runtime-asset.ts";
 
 const BUN_SKILL_BASE_DIR = dirname(fileURLToPath(import.meta.url));
 
@@ -27,29 +28,62 @@ export function bunVersionSupportsSkill(version: string | undefined): boolean {
 	return major > 1 || (major === 1 && minor >= 4);
 }
 
-/** Absolute path of the bundled bun-1-4 SKILL.md, or undefined (logged once) when it is not shipped. */
-export function bundledBunSkillPath(baseDir: string = BUN_SKILL_BASE_DIR): string | undefined {
-	const candidate = join(baseDir, "..", "skill", "bun-1-4", "SKILL.md");
+const BUN_SKILL_PACKAGE_RELATIVE_PATH = join("skill", "bun-1-4", "SKILL.md");
+
+/**
+ * Absolute path of the bundled bun-1-4 SKILL.md, or undefined (logged once) when it is not shipped.
+ *
+ * A compiled Bun binary has no readable module-relative asset, so resolution falls back to the
+ * codemode sidecar shipped next to the executable, exactly as the Ruby and Julia kernel runners do.
+ * The miss is reported on stderr because stdout carries the RPC protocol stream.
+ */
+export function bundledBunSkillPath(
+	baseDir: string = BUN_SKILL_BASE_DIR,
+	environment: CodemodeRuntimeAssetEnvironment = {},
+): string | undefined {
+	const localPath = join(baseDir, "..", "skill", "bun-1-4", "SKILL.md");
+	const candidate = resolveCodemodeRuntimeAsset(localPath, BUN_SKILL_PACKAGE_RELATIVE_PATH, environment);
 	if (existsSync(candidate)) return candidate;
 	if (!loggedMissingBunSkill) {
 		loggedMissingBunSkill = true;
-		console.debug(`[senpi-codemode] bundled bun-1-4 skill not found at ${candidate}; skipping contribution`);
+		// A compiled binary never has the module-relative asset, so naming only that path
+		// would hide the sidecar location an operator actually has to populate.
+		const executableDir = dirname(environment.executablePath ?? process.execPath);
+		const sidecarPath = join(
+			executableDir,
+			"node_modules",
+			"@code-yeongyu",
+			"senpi-codemode",
+			"src",
+			BUN_SKILL_PACKAGE_RELATIVE_PATH,
+		);
+		console.error(
+			`[senpi-codemode] bundled bun-1-4 skill not found at ${localPath} or ${sidecarPath}; skipping contribution`,
+		);
 	}
 	return undefined;
 }
 
 /**
- * Builds the `resources_discover` handler that contributes the bundled bun-1-4 skill
- * only when the in-process js eval kernel itself runs bun >= 1.4 (`process.versions.bun`).
- * A node kernel never receives the skill, regardless of any bun binary on PATH.
+ * Absolute path of the bundled bun-1-4 SKILL.md when it is active for this process:
+ * the in-process js eval kernel itself runs bun >= 1.4 (`process.versions.bun`) and the
+ * asset is shipped. A node kernel never activates it, regardless of any bun binary on PATH.
  */
+export function activeBunSkillPath(
+	getKernelBunVersion: BunKernelVersionSource = kernelBunVersion,
+	baseDir?: string,
+): string | undefined {
+	if (!bunVersionSupportsSkill(getKernelBunVersion())) return undefined;
+	return bundledBunSkillPath(baseDir);
+}
+
+/** Builds the `resources_discover` handler that contributes the active bun-1-4 skill, if any. */
 export function createBunSkillDiscoverHandler(
 	getKernelBunVersion: BunKernelVersionSource = kernelBunVersion,
 	baseDir?: string,
 ): () => { skillPaths: string[] } | undefined {
 	return () => {
-		if (!bunVersionSupportsSkill(getKernelBunVersion())) return undefined;
-		const skillPath = bundledBunSkillPath(baseDir);
+		const skillPath = activeBunSkillPath(getKernelBunVersion, baseDir);
 		return skillPath === undefined ? undefined : { skillPaths: [skillPath] };
 	};
 }

package/src/index.ts

@@ -16,7 +16,7 @@ import {
 import { jsRuntimeInfo, jsRuntimeLabel } from "./extension/runtime-info.ts";
 import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
 import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
-import { registerBunSkillContribution } from "./extension/skill-contribution.ts";
+import { activeBunSkillPath, registerBunSkillContribution } from "./extension/skill-contribution.ts";
 import { WAKE_SOURCE_STATE_EVENT, type WakeSourceState } from "./extension/wake-source-state.ts";
 import { EvalDetachedCellManager, type EvalDetachedCellStatusEntry } from "./tool/detached-cell-manager.ts";
 import {
@@ -64,10 +64,20 @@ export interface SenpiCodemodeOptions {
 	readonly now?: () => number;
 }
 
+/** Whether the session registry holds `monitor`; false when the runtime cannot be read yet. */
+function monitorIsRegistered(pi: CodemodeExtensionAPI): boolean {
+	try {
+		return pi.getAllTools().some((tool) => tool.name === "monitor");
+	} catch {
+		return false;
+	}
+}
+
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
+	const bunSkillPath = activeBunSkillPath();
 	let activeRuntime: SessionRuntime | undefined;
 	let activeModelId: string | undefined;
 	let activeContext: ExtensionContext | undefined;
@@ -107,6 +117,11 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			pi.rpc?.emit(EVAL_EXECUTION_EVENT, toEvalExecutionRpcPayload(payload));
 			pi.events?.emit(EVAL_EXECUTION_EVENT, payload);
 		};
+		// `listTools` below survives because it is lazy; this read is eager, and the loader's
+		// action methods throw while extensions are still loading (the bundled codemode path
+		// reaches this before the runtime is bound). An unreadable registry means "do not teach
+		// a tool we cannot confirm"; session_start / model_select re-register once it is live.
+		const monitor = monitorIsRegistered(pi);
 		pi.registerTool(
 			createEvalTool({
 				enabledLanguages: runtime.enabledLanguages,
@@ -121,10 +136,12 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 				executionTracker: manager,
 				onCellSettled,
 				renderers,
+				monitor,
 				spawns: runtime.spawns,
 				spawnDefaultAgent: runtime.settings.taskTools.task,
 				hostLine: hostLine(),
 				runtimes: runtime.runtimes,
+				...(bunSkillPath === undefined ? {} : { bunSkillPath }),
 				...(modelId === undefined ? {} : { modelId }),
 			}),
 		);
@@ -157,8 +174,11 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 			}),
 			executionTracker: manager,
 			renderers,
+			// The baseline tool is registered before extensions such as monitor load.
+			monitor: false,
 			hostLine: hostLine(),
 			runtimes: { js: jsRuntimeInfo() },
+			...(bunSkillPath === undefined ? {} : { bunSkillPath }),
 		}),
 	);
 	pi.registerRemovedToolHint(

package/src/kernels/js/worker-runtime.js

@@ -3,6 +3,7 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
 import { inspect } from "node:util";
 import { awaitMaybePromise, indirectEval, wrapUserCode } from "./worker-indirect-eval.js";
+import { installShellCapture } from "./worker-shell-capture.js";
 
 const PREPARED_CELL_PREFIX = "/*senpi:prepared-cell*/";
 const INTERNAL_URL = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/iu;
@@ -84,11 +85,16 @@ export class JsWorkerRuntime {
 		process.stderr.write = routeWrite(process.stderr, originalStderrWrite, "stderr");
 		console.log = (...values) => this.#emitText("stdout", `${values.map(formatValue).join(" ")}\n`);
 		console.error = (...values) => this.#emitText("stderr", `${values.map(formatValue).join(" ")}\n`);
+		const restoreShellCapture = installShellCapture({
+			isActive: () => this.#hooks !== null,
+			emitText: (stream, data) => this.#emitText(stream, data),
+		});
 		globalThis.__senpi_restore_console__ = () => {
 			console.log = originalLog;
 			console.error = originalError;
 			process.stdout.write = originalStdoutWrite;
 			process.stderr.write = originalStderrWrite;
+			restoreShellCapture();
 		};
 	}
 

package/src/kernels/js/worker-shell-capture.d.ts

@@ -0,0 +1,10 @@
+export type ShellCaptureStream = "stdout" | "stderr";
+
+export type ShellCaptureRestore = () => void;
+
+export interface ShellCaptureOptions {
+	readonly isActive: () => boolean;
+	readonly emitText: (stream: ShellCaptureStream, data: string) => void;
+}
+
+export function installShellCapture(options: ShellCaptureOptions): ShellCaptureRestore;

package/src/kernels/js/worker-shell-capture.js

@@ -0,0 +1,126 @@
+const SHELL_CONFIG_METHODS = ["env", "cwd", "nothrow", "throws"];
+const SHELL_READ_METHODS = ["text", "json", "lines", "arrayBuffer", "bytes", "blob"];
+
+export function installShellCapture(options) {
+	const bun = globalThis.Bun;
+	if (!isBunRuntime(bun)) return () => {};
+	const originalShell = bun.$;
+	const originalSpawn = bun.spawn;
+	bun.$ = capturedShell(originalShell, options);
+	bun.spawn = capturedSpawn(originalSpawn, options);
+	return () => {
+		bun.$ = originalShell;
+		bun.spawn = originalSpawn;
+	};
+}
+
+function isBunRuntime(bun) {
+	return bun !== null && typeof bun === "object" && typeof bun.$ === "function" && typeof bun.spawn === "function";
+}
+
+function capturedShell(originalShell, options) {
+	const shell = (strings, ...expressions) => {
+		const promise = originalShell(strings, ...expressions);
+		return options.isActive() ? captureShellPromise(promise, options.emitText) : promise;
+	};
+	for (const key of Object.keys(originalShell)) shell[key] = originalShell[key];
+	for (const method of SHELL_CONFIG_METHODS) {
+		shell[method] = (...args) => {
+			originalShell[method](...args);
+			return shell;
+		};
+	}
+	return shell;
+}
+
+function captureShellPromise(promise, emitText) {
+	const prototype = Object.getPrototypeOf(promise);
+	let echo = true;
+	const echoOnce = (output) => {
+		if (!echo) return;
+		echo = false;
+		emitShellOutput(output, emitText);
+	};
+	prototype.quiet.call(promise);
+	promise.quiet = function quiet() {
+		echo = false;
+		return prototype.quiet.call(this);
+	};
+	for (const method of SHELL_READ_METHODS) {
+		if (typeof prototype[method] !== "function") continue;
+		promise[method] = function read(...args) {
+			echo = false;
+			return prototype[method].apply(this, args);
+		};
+	}
+	promise.then = function then(onFulfilled, onRejected) {
+		return prototype.then.call(
+			this,
+			(output) => {
+				echoOnce(output);
+				return onFulfilled ? onFulfilled(output) : output;
+			},
+			(error) => {
+				echoOnce(error);
+				if (onRejected) return onRejected(error);
+				throw error;
+			},
+		);
+	};
+	return promise;
+}
+
+function emitShellOutput(output, emitText) {
+	if (output === null || typeof output !== "object") return;
+	const stdout = outputText(output.stdout);
+	if (stdout) emitText("stdout", stdout);
+	const stderr = outputText(output.stderr);
+	if (stderr) emitText("stderr", stderr);
+}
+
+function outputText(value) {
+	if (value instanceof Uint8Array) return new TextDecoder().decode(value);
+	return typeof value === "string" ? value : "";
+}
+
+function capturedSpawn(originalSpawn, options) {
+	return (...args) => {
+		if (!options.isActive()) return originalSpawn(...args);
+		const [first, second] = args;
+		if (Array.isArray(first)) {
+			const spawnOptions = second === undefined ? {} : second;
+			if (!needsStderrCapture(spawnOptions)) return originalSpawn(...args);
+			return drainStderr(originalSpawn(first, { ...spawnOptions, stderr: "pipe" }), options.emitText);
+		}
+		if (!needsStderrCapture(first)) return originalSpawn(...args);
+		return drainStderr(originalSpawn({ ...first, stderr: "pipe" }), options.emitText);
+	};
+}
+
+function needsStderrCapture(spawnOptions) {
+	return (
+		spawnOptions !== null &&
+		typeof spawnOptions === "object" &&
+		spawnOptions.stdio === undefined &&
+		spawnOptions.stderr === undefined
+	);
+}
+
+function drainStderr(child, emitText) {
+	const stream = child?.stderr;
+	if (!(stream instanceof ReadableStream)) return child;
+	void readStream(stream, emitText).catch((error) => {
+		emitText("stderr", `[spawn stderr capture failed: ${String(error)}]\n`);
+	});
+	return child;
+}
+
+async function readStream(stream, emitText) {
+	const decoder = new TextDecoder();
+	for await (const chunk of stream) {
+		const text = decoder.decode(chunk, { stream: true });
+		if (text) emitText("stderr", text);
+	}
+	const tail = decoder.decode();
+	if (tail) emitText("stderr", tail);
+}

package/src/prompt/eval-prompt.ts

@@ -1,3 +1,5 @@
+import type { EvalRuntimeInfo } from "../tool/types.ts";
+
 export interface EnabledLanguages {
 	readonly py: boolean;
 	readonly js: boolean;
@@ -13,11 +15,17 @@ export interface EvalPromptParts {
 
 export interface EvalPromptOptions {
 	readonly spawns: boolean;
+	/** Whether the session registry exposes the monitor tool through eval. */
+	readonly monitor?: boolean;
 	readonly spawnDefaultAgent?: string;
 	/** Active model id; selects the emphasis dialect of the batching guidance. */
 	readonly modelId?: string;
 	/** Preformatted host line (e.g. "darwin arm64 · Apple M5 Max · 18 cores"); enables the host-sizing note. */
 	readonly hostLine?: string;
+	/** Identity of the in-process js kernel; a bun runtime swaps the Node.js worker line for the Bun one. */
+	readonly jsRuntime?: EvalRuntimeInfo;
+	/** Absolute path of the active bun-1-4 skill; rendered as a MUST READ pointer only on a bun kernel. */
+	readonly bunSkillPath?: string;
 }
 
 /** Prompt dialect for the eval-first batching emphasis. */
@@ -99,21 +107,26 @@ Work incrementally: imports in one call, define in the next, test, then use —
 \`eval\` is your default execution surface: if a step needs more than one tool call, write ONE cell that performs the whole step — never issue the calls one at a time.
 - Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
 - Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
-- Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
+- Post-process \`tool.<name>()\` results programmatically — filter, join, aggregate — and return distilled facts, not raw dumps.
+{{#if monitor}}- Start long-running work (build, test run, deploy, or watch) through \`tool.monitor({ command, filter })\`, putting the decisive-line filter inside the same cell, then keep working until its event wakes the turn; sleeping, timed retries, and repeated status reads are not waiting.{{/if}}
 </eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
 GPT eval: compose multi-tool work inside one cell with \`tool.<name>(args)\` and \`parallel(thunks)\`; do not split a planned step into serial tool calls.
 - Long pure-compute cells detach on timeout and notify on completion. Do not poll or re-run them; use \`eval({ action: "peek"|"stop", cell_id })\` only to inspect or stop a detached cell.
-- Reduce tool results in the cell and return only decision-relevant facts.
+- Filter, join, and aggregate tool results in the cell; return only decision-relevant facts.
+{{#if monitor}}- For long-running build, test run, deploy, or watch work, start \`tool.monitor({ command, filter })\` with the decisive-line filter in the same cell; keep working while its event wakes the turn; sleeping, timed retries, and repeated status reads are not waiting.{{/if}}
 </gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
-- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
+- Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically — filter, join, aggregate.
 - Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
-- Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
+- Reduce large results in-kernel to the facts the task needs before returning.
+{{#if monitor}}- Long-running build/test/deploy/watch work: start \`tool.monitor({ command, filter })\` with the decisive-line filter inside the same cell, then continue working; its event wakes the turn — sleeping, timed retries, and repeated status reads are not waiting.{{/if}}{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
 - **BATCH EVERYTHING AT ONCE:** enumerate EVERY independent lookup the step needs and dispatch them ALL simultaneously with \`parallel(thunks)\` in that cell; keep calls sequential only when one result feeds the next.
 - **WRITE REAL CODE, NOT CALL CHAINS:** loop or comprehend over file sets with \`read()\`/stdlib, post-process \`tool.<name>()\` results programmatically, and put try/except around each risky call so the rest of the batch completes.
-- **DISTILL IN-KERNEL:** filter and aggregate results in code, then return ONLY the distilled facts.{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
+- **DISTILL IN-KERNEL:** filter, join, and aggregate \`tool.<name>()\` results in code, then return ONLY the distilled facts.
+{{#if monitor}}- **DO start long-running build, test run, deploy, or watch work with \`tool.monitor({ command, filter })\`, put the decisive-line filter INSIDE THE SAME CELL, and KEEP WORKING until its event wakes the turn; sleeping, timed retries, and repeated status reads are not waiting.**{{/if}}{{/if}}{{#if styleDefault}}**EVAL IS YOUR PRIMARY EXECUTION SURFACE.** Any step that needs MORE THAN ONE tool call MUST be written as ONE cell — NEVER as a chain of single tool calls.
 - **PLAN THE WHOLE STEP, THEN BATCH IT.** Enumerate every read/search/lookup the step needs and dispatch ALL independent ones through \`parallel(thunks)\` in one cell.
 - **WRITE REAL CODE, NOT CALL LISTS.** Loop or comprehend over file sets with \`read()\`/stdlib, branch \`if\`/\`else\` per case, post-process \`tool.<name>()\` results programmatically, and wrap EVERY risky call in try/except so ONE failure NEVER kills the batch.
-- **DISTILL IN-KERNEL.** Filter, diff, and aggregate in code before returning; return facts, NOT dumps.{{/if}}
+- **DISTILL IN-KERNEL.** Filter, join, diff, and aggregate in code before returning; return facts, NOT dumps.
+{{#if monitor}}- **LONG-RUNNING build, test run, deploy, or watch work MUST start with \`tool.monitor({ command, filter })\`, with the decisive-line filter INSIDE THE SAME CELL; KEEP WORKING until its event wakes the turn — SLEEPING, TIMED RETRIES, AND REPEATED STATUS READS ARE NOT WAITING.**{{/if}}{{/if}}
 {{#if hostLine}}
 Host: {{hostLine}} — cells execute here. Size \`parallel(thunks)\` pools to its cores; \`tool.<name>()\` shell commands must fit this platform, even when the code you are writing targets another machine.
 {{/if}}
@@ -132,7 +145,7 @@ Fields:
 A detached cell keeps its language kernel busy while it finishes; another language can continue. Do not re-run a detached cell: the same-language busy error names its cell id and output tail. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
 
 {{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
-{{#if js}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available.{{#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}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
 On error, fix and re-run only the failing step. State usually survives a normal error, but a timeout or stop may have restarted the kernel — its message says which. Before rebuilding state, check a sentinel (a variable you defined earlier); only re-establish what is actually gone, since blind re-runs duplicate side effects.
@@ -205,6 +218,7 @@ export function buildEvalPrompt(
 		rb: enabled.rb,
 		jl: enabled.jl,
 		spawns: options.spawns,
+		monitor: options.monitor === true,
 		spawnDefaultAgent,
 		styleClaude: style === "claude",
 		styleCodex: style === "codex",
@@ -212,6 +226,9 @@ export function buildEvalPrompt(
 		styleKimi: style === "kimi",
 		styleDefault: style === "default",
 		hostLine: options.hostLine ?? "",
+		jsBun: options.jsRuntime?.name === "bun",
+		jsVersion: options.jsRuntime?.version ?? "",
+		bunSkillPath: options.bunSkillPath ?? "",
 	};
 	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
 		.map((example) => {

package/src/skill/bun-1-4/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: bun-1-4
-description: "MUST USE whenever writing or running JavaScript/TypeScript with Bun — including JS through the eval tool, bun -e one-liners, scratch scripts, servers, CLIs, tests, bundling, or package management. Bun 1.4 replaced 15+ npm deps with builtins: consult BEFORE npm-installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width — Bun ships it. Triggers: bun, Bun.serve, bun test, bun build, bun install, bun run, JS 스크립트, 번들링, 이미지 리사이즈, 헤드리스 브라우저, 크론, PTY, eval js."
+description: "MUST READ before your first js eval cell: this session's eval js kernel runs Bun 1.4+ (this skill is present only when it does). Also read before any bun -e, script, server, CLI, test, bundle, or package-management work. Bun 1.4 ships builtins that replace 15+ npm deps — check here BEFORE installing sharp, puppeteer/playwright (scraping), marked, node-cron, node-pty, concurrently, serve-static, tar, json5, fast-xml-parser, string-width. Triggers: eval js, bun, Bun.serve, bun test, bun build, bun install, bun run, image resize, headless browser, markdown render, cron, PTY."
 ---
 
 # Bun 1.4 — Use the Builtins First

package/src/skill/bun-1-4/references/runtime-apis.md

@@ -139,7 +139,7 @@ Blog: [#also-built-in](https://bun.com/blog/bun-v1.4#also-built-in)
 Docs: <https://bun.com/docs/runtime/utils>
 
 ```ts
-Bun.stringWidth("한글 text");     // terminal columns, ANSI + grapheme aware
+Bun.stringWidth("\x1b[32mgreen\x1b[0m e\u0301"); // terminal columns, ANSI + grapheme aware
 Bun.sliceAnsi(str, 0, 20);        // slice by columns, preserving ANSI codes
 Bun.wrapAnsi(str, 80);            // wrap by columns
 ```

package/src/tool/eval-tool-options.ts

@@ -36,11 +36,15 @@ export interface CreateEvalToolOptions {
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
 	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;
 	readonly spawns?: boolean;
+	/** Whether the session registry exposes the monitor tool through eval. */
+	readonly monitor?: boolean;
 	readonly spawnDefaultAgent?: string;
 	readonly modelId?: string;
 	readonly hostLine?: string;
-	/** Display identity of each language's runtime, shown in headers and details. */
+	/** Display identity of each language's runtime, shown in headers and details; `js` also selects the prompt's runtime line. */
 	readonly runtimes?: EvalRuntimes;
+	/** Absolute path of the active bun-1-4 skill; the prompt names it as MUST READ on a bun kernel. */
+	readonly bunSkillPath?: string;
 }
 
 export interface EvalCellInvocation {

package/src/tool/eval-tool.ts

@@ -28,9 +28,12 @@ export function createEvalTool(options: CreateEvalToolOptions): ToolDefinition<E
 	const parameters = createEvalInputSchema(options.enabledLanguages);
 	const prompt = buildEvalPrompt(options.enabledLanguages, {
 		spawns: options.spawns ?? false,
+		monitor: options.monitor,
 		...(options.spawnDefaultAgent === undefined ? {} : { spawnDefaultAgent: options.spawnDefaultAgent }),
 		...(options.modelId === undefined ? {} : { modelId: options.modelId }),
 		...(options.hostLine === undefined ? {} : { hostLine: options.hostLine }),
+		...(options.runtimes?.js === undefined ? {} : { jsRuntime: options.runtimes.js }),
+		...(options.bunSkillPath === undefined ? {} : { bunSkillPath: options.bunSkillPath }),
 	});
 	const languages = enabledLanguageList(options.enabledLanguages);
 	const cellManager =