@code-yeongyu/senpi 2026.9.4 → 2026.9.5

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

@@ -0,0 +1,162 @@
+const BASE64_STRICT_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/u;
+const DATA_URL_RE = /^data:([^;,]+)(?:;[^,]*)?;base64,([\s\S]*)$/u;
+
+const IMAGE_SIGNATURES = [
+	{ mimeType: "image/png", offset: 0, bytes: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] },
+	{ mimeType: "image/jpeg", offset: 0, bytes: [0xff, 0xd8, 0xff] },
+	{ mimeType: "image/gif", offset: 0, bytes: [0x47, 0x49, 0x46, 0x38] },
+	{ mimeType: "image/webp", offset: 8, bytes: [0x57, 0x45, 0x42, 0x50] },
+	{ mimeType: "image/bmp", offset: 0, bytes: [0x42, 0x4d] },
+];
+
+export function sniffImageMimeType(bytes) {
+	for (const signature of IMAGE_SIGNATURES) {
+		if (bytes.length < signature.offset + signature.bytes.length) continue;
+		if (signature.bytes.every((byte, index) => bytes[signature.offset + index] === byte)) return signature.mimeType;
+	}
+	return undefined;
+}
+
+export function isBinaryData(value) {
+	return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+
+function bytesOf(value) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	return undefined;
+}
+
+function normalizeBase64(text) {
+	const compact = text.replace(/\s+/gu, "").replace(/-/gu, "+").replace(/_/gu, "/");
+	const padded = compact.length % 4 === 0 ? compact : `${compact}${"=".repeat(4 - (compact.length % 4))}`;
+	return padded.length > 0 && BASE64_STRICT_RE.test(padded) ? padded : undefined;
+}
+
+function decimalCsvBase64(text) {
+	const parts = text.split(",");
+	const bytes = new Uint8Array(parts.length);
+	for (let index = 0; index < parts.length; index += 1) {
+		const byte = Number(parts[index]);
+		if (!Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
+		bytes[index] = byte;
+	}
+	return Buffer.from(bytes).toString("base64");
+}
+
+function serializedBufferBase64(data) {
+	const bytes = new Uint8Array(data.length);
+	for (let index = 0; index < data.length; index += 1) {
+		const byte = data[index];
+		if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
+		bytes[index] = byte;
+	}
+	return Buffer.from(bytes).toString("base64");
+}
+
+export function imagePayload(data) {
+	if (typeof data === "string") {
+		const dataUrl = DATA_URL_RE.exec(data);
+		if (dataUrl) {
+			const dataBase64 = normalizeBase64(dataUrl[2]);
+			return dataBase64 === undefined ? undefined : { dataBase64, mimeType: dataUrl[1] };
+		}
+		const dataBase64 = normalizeBase64(data);
+		if (dataBase64 !== undefined) return { dataBase64 };
+		return DECIMAL_CSV_RE.test(data) ? wrap(decimalCsvBase64(data)) : undefined;
+	}
+	const bytes = bytesOf(data);
+	if (bytes !== undefined) return { dataBase64: Buffer.from(bytes).toString("base64"), mimeType: sniffImageMimeType(bytes) };
+	if (isSerializedBuffer(data)) return wrap(serializedBufferBase64(data.data));
+	return undefined;
+}
+
+function wrap(dataBase64) {
+	return dataBase64 === undefined ? undefined : { dataBase64 };
+}
+
+function isSerializedBuffer(data) {
+	return (
+		typeof data === "object" &&
+		data !== null &&
+		Object.getPrototypeOf(data) === Object.prototype &&
+		data.type === "Buffer" &&
+		Array.isArray(data.data)
+	);
+}
+
+function describeImageData(data) {
+	if (data === null) return "null";
+	if (data instanceof Uint8Array) return "Uint8Array";
+	if (data instanceof ArrayBuffer) return "ArrayBuffer";
+	if (ArrayBuffer.isView(data)) return data.constructor.name;
+	if (typeof data === "string") return `string(${data.length})`;
+	return typeof data;
+}
+
+function isImageFrame(value) {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		typeof value.mimeType === "string" &&
+		typeof value.dataBase64 === "string"
+	);
+}
+
+function isMarshalledToolResult(value) {
+	return typeof value.text === "string" && Array.isArray(value.images) && value.images.every(isImageFrame);
+}
+
+function isEncodableImage(value) {
+	return !isBinaryData(value) && (typeof value.arrayBuffer === "function" || typeof value.bytes === "function");
+}
+
+function frame(mimeType, dataBase64) {
+	return { kind: "frame", mimeType, dataBase64 };
+}
+
+function dropped(reason) {
+	return [{ kind: "text", text: `[display: image dropped — ${reason}]` }];
+}
+
+export function resolveDisplayOps(value) {
+	if (typeof value !== "object" || value === null) return undefined;
+	if (value.type === "image" && typeof value.mimeType === "string") {
+		const payload = imagePayload(value.data);
+		return payload === undefined
+			? dropped(
+					`\`data\` must be a base64 string, data: URL, Uint8Array/Buffer, or ArrayBuffer; got ${describeImageData(value.data)}`,
+				)
+			: [frame(value.mimeType, payload.dataBase64)];
+	}
+	if (isImageFrame(value)) return [frame(value.mimeType, value.dataBase64)];
+	if (isMarshalledToolResult(value)) {
+		const frames = value.images.map((image) => frame(image.mimeType, image.dataBase64));
+		return value.text === "" ? frames : [{ kind: "text", text: value.text }, ...frames];
+	}
+	if (isBinaryData(value)) {
+		const payload = imagePayload(value);
+		return [frame(payload.mimeType ?? "application/octet-stream", payload.dataBase64)];
+	}
+	if (isEncodableImage(value)) return [{ kind: "encode", value }];
+	return undefined;
+}
+
+export async function encodeDisplayImage(value) {
+	let raw;
+	try {
+		raw = typeof value.bytes === "function" ? await value.bytes() : await value.arrayBuffer();
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return dropped(`encoding failed: ${error.message}`);
+	}
+	const bytes = bytesOf(raw);
+	if (bytes === undefined) return dropped(`encoder returned ${describeImageData(raw)}, not bytes`);
+	const declared = typeof value.type === "string" && value.type.startsWith("image/") ? value.type : undefined;
+	const mimeType = declared ?? sniffImageMimeType(bytes);
+	return mimeType === undefined
+		? dropped("bytes carry no recognizable image signature")
+		: [frame(mimeType, Buffer.from(bytes).toString("base64"))];
+}

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

@@ -1,12 +1,12 @@
 export const JAVASCRIPT_KERNEL_PRELUDE = [
 	"print(...values): write stdout text.",
-	"display(value): emit JSON, image, or markdown display output.",
+	"display(value): emit JSON, markdown, or image display output; image bytes, data: URLs, Blob-like values, tool results, and their images[i] frames all render as images.",
 	"log(message): emit a progress log line.",
 	"phase(title): emit a progress phase.",
 	"env(key?, value?): read, set, or list environment values.",
 	"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.",
+	"tool.<name>(args): request a host tool call through the bridge; resolves to { text, images?, details?, hasError? }.",
 	"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.",

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

@@ -2,13 +2,12 @@
 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 { encodeDisplayImage, resolveDisplayOps } from "./display-image.js";
 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;
-const BASE64_STRICT_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
-const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/u;
 
 export class JsWorkerRuntime {
 	#cwd;
@@ -16,6 +15,7 @@ export class JsWorkerRuntime {
 	#localRoots;
 	#env = new Map();
 	#hooks = null;
+	#pendingDisplays = [];
 
 	constructor(options) {
 		this.#cwd = options.cwd;
@@ -36,12 +36,23 @@ export class JsWorkerRuntime {
 				({ prelude, code: cellCode } = prepared);
 			}
 			if (prelude) indirectEval(prelude, `${cellId}:prelude`);
-			return await awaitMaybePromise(indirectEval(wrapUserCode(cellCode), cellId));
+			const value = await awaitMaybePromise(indirectEval(wrapUserCode(cellCode), cellId));
+			await this.#drainPendingDisplays();
+			return value;
 		} finally {
+			this.#pendingDisplays = [];
 			this.#hooks = null;
 		}
 	}
 
+	async #drainPendingDisplays() {
+		while (this.#pendingDisplays.length > 0) {
+			const pending = this.#pendingDisplays;
+			this.#pendingDisplays = [];
+			await Promise.all(pending);
+		}
+	}
+
 	#installGlobals() {
 		globalThis.print = (...values) => this.#emitText("stdout", `${values.map(formatValue).join(" ")}\n`);
 		globalThis.display = value => this.#display(value);
@@ -112,22 +123,8 @@ export class JsWorkerRuntime {
 				this.#hooks?.emit({ type: "display", mimeType: "text/markdown", dataBase64: encodeBase64(value.text) });
 				return;
 			}
-			if (value.type === "image" && typeof value.mimeType === "string") {
-				const dataBase64 = imageBase64(value.data);
-				if (dataBase64 !== undefined) {
-					this.#hooks?.emit({ type: "display", mimeType: value.mimeType, dataBase64 });
-					return;
-				}
-				this.#emitText(
-					"stdout",
-					`[display: image dropped — \`data\` must be a base64 string, Uint8Array/Buffer, or ArrayBuffer; got ${describeImageData(value.data)}]\n`,
-				);
-				return;
-			}
-			if (typeof value.mimeType === "string" && typeof value.dataBase64 === "string") {
-				this.#hooks?.emit({ type: "display", mimeType: value.mimeType, dataBase64: value.dataBase64 });
-				return;
-			}
+			const ops = resolveDisplayOps(value);
+			if (ops !== undefined) return this.#applyDisplayOps(ops);
 			try {
 				this.#hooks?.emit({ type: "display", mimeType: "application/json", dataBase64: encodeBase64(JSON.stringify(value)) });
 			} catch (error) {
@@ -139,6 +136,19 @@ export class JsWorkerRuntime {
 		this.#emitText("stdout", `${String(value)}\n`);
 	}
 
+	#applyDisplayOps(ops) {
+		let pending;
+		for (const op of ops) {
+			if (op.kind === "frame") this.#hooks?.emit({ type: "display", mimeType: op.mimeType, dataBase64: op.dataBase64 });
+			else if (op.kind === "text") this.#emitText("stdout", `${op.text}\n`);
+			else {
+				pending = encodeDisplayImage(op.value).then((encoded) => this.#applyDisplayOps(encoded));
+				this.#pendingDisplays.push(pending);
+			}
+		}
+		return pending;
+	}
+
 	#envHelper(key, value) {
 		if (key === undefined || key === null || key === "") {
 			const merged = Object.fromEntries(Object.entries({ ...process.env, ...Object.fromEntries(this.#env) }).sort());
@@ -357,47 +367,6 @@ async function writeData(value) {
 	throw new TypeError("write() expects string, Blob, ArrayBuffer, or TypedArray data");
 }
 
-function imageBase64(data) {
-	if (typeof data === "string") {
-		if (isStrictBase64(data)) return data;
-		if (!DECIMAL_CSV_RE.test(data)) return undefined;
-		const parts = data.split(",");
-		const bytes = new Uint8Array(parts.length);
-		for (let index = 0; index < parts.length; index += 1) {
-			const byte = Number(parts[index]);
-			if (!Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
-			bytes[index] = byte;
-		}
-		return Buffer.from(bytes).toString("base64");
-	}
-	if (data instanceof Uint8Array) return Buffer.from(data).toString("base64");
-	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("base64");
-	if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
-	if (isPlainObject(data) && data.type === "Buffer" && Array.isArray(data.data)) {
-		const bytes = new Uint8Array(data.data.length);
-		for (let index = 0; index < data.data.length; index += 1) {
-			const byte = data.data[index];
-			if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) return undefined;
-			bytes[index] = byte;
-		}
-		return Buffer.from(bytes).toString("base64");
-	}
-	return undefined;
-}
-
-function isStrictBase64(value) {
-	return value.length > 0 && value.length % 4 === 0 && BASE64_STRICT_RE.test(value);
-}
-
-function describeImageData(data) {
-	if (data === null) return "null";
-	if (data instanceof Uint8Array) return "Uint8Array";
-	if (data instanceof ArrayBuffer) return "ArrayBuffer";
-	if (ArrayBuffer.isView(data)) return data.constructor.name;
-	if (typeof data === "string") return `string(${data.length})`;
-	return typeof data;
-}
-
 function chunkToString(chunk, encoding) {
 	if (typeof chunk === "string") return chunk;
 	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString(encoding ?? "utf8");

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

@@ -91,6 +91,68 @@ def b64_text(value: str) -> str:
     return base64.b64encode(value.encode("utf-8")).decode("ascii")
 
 
+_IMAGE_SIGNATURES: tuple[tuple[str, int, bytes], ...] = (
+    ("image/png", 0, b"\x89PNG\r\n\x1a\n"),
+    ("image/jpeg", 0, b"\xff\xd8\xff"),
+    ("image/gif", 0, b"GIF8"),
+    ("image/webp", 8, b"WEBP"),
+    ("image/bmp", 0, b"BM"),
+)
+_DATA_URL_RE = re.compile(r"^data:([^;,]+)(?:;[^,]*)?;base64,(.*)$", re.DOTALL)
+
+
+def _sniff_image_mime_type(data: bytes) -> str | None:
+    for mime_type, offset, magic in _IMAGE_SIGNATURES:
+        if data[offset : offset + len(magic)] == magic:
+            return mime_type
+    return None
+
+
+def _image_base64(data: Any) -> tuple[str, str | None] | None:
+    if isinstance(data, (bytes, bytearray)):
+        raw = bytes(data)
+        return base64.b64encode(raw).decode("ascii"), _sniff_image_mime_type(raw)
+    if not isinstance(data, str):
+        return None
+    declared: str | None = None
+    match = _DATA_URL_RE.match(data)
+    if match:
+        declared, data = match.group(1), match.group(2)
+    compact = re.sub(r"\s+", "", data).replace("-", "+").replace("_", "/")
+    compact += "=" * (-len(compact) % 4)
+    try:
+        base64.b64decode(compact, validate=True)
+    except (ValueError, TypeError):
+        return None
+    return (compact, declared) if compact else None
+
+
+def _display_image_dict(value: dict[str, Any]) -> bool:
+    mime_type = value.get("mimeType")
+    payload = value.get("dataBase64") if "dataBase64" in value else value.get("data")
+    if not isinstance(mime_type, str) or not mime_type.startswith("image/") or payload is None:
+        return False
+    encoded = _image_base64(payload)
+    if encoded is None:
+        print(f"[display: image dropped \u2014 `data` must be base64, a data: URL, or bytes; got {type(payload).__name__}]")
+        return True
+    emit({"type": "display", "mimeType": mime_type, "dataBase64": encoded[0]})
+    return True
+
+
+def _display_tool_result(value: dict[str, Any]) -> bool:
+    text, images = value.get("text"), value.get("images")
+    if not isinstance(text, str) or not isinstance(images, list):
+        return False
+    if not all(isinstance(image, dict) and isinstance(image.get("mimeType"), str) and isinstance(image.get("dataBase64"), str) for image in images):
+        return False
+    if text:
+        print(text)
+    for image in images:
+        emit({"type": "display", "mimeType": image["mimeType"], "dataBase64": image["dataBase64"]})
+    return True
+
+
 def _emit_display(mime_type: str, data: Any) -> None:
     if isinstance(data, (bytes, bytearray)):
         encoded = base64.b64encode(bytes(data)).decode("ascii")
@@ -188,11 +250,14 @@ def _rich_bundle(value: Any) -> dict[str, Any]:
 
 
 def display(value: Any) -> None:
+    if isinstance(value, dict) and (_display_tool_result(value) or _display_image_dict(value)):
+        return
     if isinstance(value, (dict, list, tuple)):
         _emit_display("application/json", value)
         return
     if isinstance(value, (bytes, bytearray)):
-        _emit_display("application/octet-stream", bytes(value))
+        raw = bytes(value)
+        _emit_display(_sniff_image_mime_type(raw) or "application/octet-stream", raw)
         return
     bundle = _rich_bundle(value)
     if bundle and _display_bundle(bundle):

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

@@ -64,98 +64,55 @@ export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyl
 
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
-type EvalPromptExample = {
-	readonly caption: string;
-	readonly language: keyof EnabledLanguages;
-	readonly summary: string;
-	readonly code: string;
-};
-
-// senpi ToolDefinition has no examples field, so description embeds the examples.
-// ADAPTATION: payloads diverge from omp's json-config chain to teach batch read,
-// comprehension filtering, and parallel tool.<name> fan-out while keeping the
-// three-cell reuse narrative.
-const REUSE_CHAIN_EXAMPLES = [
-	{
-		caption: "First call — set up once",
-		language: "js",
-		summary: "Count all TypeScript source files under src/ excluding tests",
-		code: "import { readdir } from 'node:fs/promises'\nimport { extname } from 'node:path'\nconst files = (await readdir('src', { recursive: true })).filter(f => extname(f) === '.ts' && !f.includes('test'))\nprint(files.length)",
-	},
-	{
-		caption: "Second call — reuse `files`, fan out session tools in parallel",
-		language: "js",
-		summary: "Grep legacyClient per directory in one cell",
-		code: "const dirs = [...new Set(files.map(f => f.split('/')[0]))]\nconst hits = await Promise.all(dirs.map(d => tool.grep({ pattern: 'legacyClient', path: d })))\ndisplay(hits.map(h => h.matches?.length ?? 0))",
-	},
-	{
-		caption: "JS kernel is busy with a detached cell — continue in py",
-		language: "py",
-		summary: "Aggregate legacyClient hits while JS is busy",
-		code: "from pathlib import Path\nprint(sum('legacyClient' in read(p) for p in Path('src').rglob('*.ts')))",
-	},
-] as const satisfies readonly EvalPromptExample[];
-
 const EVAL_PROMPT_TEMPLATE = `Run one step of code in a persistent kernel.
 
 <instruction>
-**One eval call = one cell = one logical step.** State persists per language across separate eval calls and tool calls{{#if spawns}}, and \`task\` subagents{{/if}} — define helpers, datasets, and clients in one call, then later calls reuse them directly.
-
-Work incrementally: imports in one call, define in the next, test, then use — each its own eval call. Re-run setup ONLY after \`reset\`, a kernel crash, or a \`NameError\`/\`ReferenceError\` proving the state is gone.
+**One eval call = one cell = one logical step.** Top-level names persist per language across eval calls{{#if spawns}}, tool calls and \`task\` subagents{{else}} and tool calls{{/if}}: define helpers and clients once and reuse them instead of re-importing or re-reading. Rebuild state only after \`reset\`, a kernel restart, or a \`NameError\`/\`ReferenceError\`, and check a sentinel variable first so a re-run cannot duplicate side effects.
 
 {{#if styleClaude}}<eval_first_batching>
 \`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 — 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}}
+{{#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.{{/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.
+- Long cells detach on timeout and notify on completion; do not poll or re-run them.
 - 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}}
+{{#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 until its event wakes the turn.{{/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 — 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 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.
+{{#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 until its event wakes the turn.{{/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, 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.
+{{#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.**{{/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, 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 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.**{{/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}}
 
-Fields:
-
-- \`language\` — {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
-- \`code\` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
-- \`summary\` (REQUIRED for run) — ONE line in the USER'S conversational language stating WHAT this cell does and FOR WHAT PURPOSE (e.g. Korean conversation -> "src 전체에서 legacyClient 사용처 집계"); shown in the TUI while the cell runs; >80 chars is force-truncated.
-- \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
-- \`on_timeout\` (optional) — \`"detach"\` keeps pure computation running in interactive sessions (the default); \`"error"\` interrupts for deadline-sensitive work and is the print/json default.
-- Every cell is killed at a wall-clock hard limit (default 1800s) that survives detach and is never paused by tool calls; a larger explicit \`timeout\` raises it, and a killed cell notifies you that it hit the limit.
-- \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
-- \`action\` (optional) — defaults to \`"run"\`. A detached cell returns its id: use \`eval({ action: "peek", cell_id })\` for buffered output/state or \`eval({ action: "stop", cell_id })\` to cancel it.
+\`language\`: {{#if py}}\`"py"\` IPython kernel{{/if}}{{#ifAll py js}}, {{/ifAll}}{{#if js}}\`"js"\` persistent JavaScript VM{{/if}}{{#if rb}}{{#ifAny py js}}, {{/ifAny}}\`"rb"\` persistent Ruby kernel{{/if}}{{#if jl}}{{#ifAny py js rb}}, {{/ifAny}}\`"jl"\` persistent Julia kernel{{/if}}.
 
-A 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.
+A cell that outlives the foreground window detaches: it keeps its language kernel busy (another language can continue) and completes as one notification with its value or error and buffered output. Do not re-run a detached cell; read or cancel it with \`eval({ action: "peek", cell_id })\` / \`eval({ action: "stop", cell_id })\`.
 
-{{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/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 py}}Python runs on a live event loop: use top-level \`await\`; \`asyncio.run(…)\` raises.{{/if}}
+{{#if js}}{{#if jsBun}}JS runs in-process on Bun {{jsVersion}}: top-level \`await\`/\`return\` work; \`Bun.*\` builtins available, including \`new Bun.WebView()\` — a headless browser (navigate/click/evaluate/screenshot) to reach for before \`curl\` or a browser CLI when a page needs JS, a login, or a screenshot.{{#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.
+On error, fix and re-run only the failing step; a normal error keeps state, while a timeout or stop message says whether the kernel restarted.
 </instruction>
 
 <prelude>
 {{#ifAll py js}}Same helpers + arg order, both runtimes. Python: sync, options = trailing kwargs. JS: async/\`await\`able, options = ONE trailing object literal, never positional (extras throw).{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional (extras throw).{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
 \`\`\`
 display(value) → None
-    Cell output; figures/images/dataframes shown natively.
+    Cell output. Images reach you only through display: pass a figure, image bytes, a tool result, or its \`images[i]\`.
 print(value, ...) → None
     Text output.
 read(path, offset?=1, limit?=None) → str
@@ -163,25 +120,21 @@ read(path, offset?=1, limit?=None) → str
 write(path, content) → str
     Write file (creates parents) → resolved path. \`local://…\` persists across turns/subagents.
 env(key?=None, value?=None) → str | None | dict
-    No args → full env dict; one → value of \`key\`; two → set \`key=value\`, return value.
+    No args → full env dict; one → value; two → set \`key=value\`.
 {{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
-    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
-{{/if}}tool.<name>(args) → unknown
-    Invoke any session tool; \`args\` = its parameter object.
+    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` \`"raw"\` = full, \`"tail"\` = trailing.
+{{/if}}tool.<name>(args) → { text, images?, details?, hasError? }
+    Invoke any session tool; image results (e.g. \`tool.read\` on a png) arrive in \`images[i]\` as { mimeType, dataBase64 }.
 tool_schema(name?) → dict
-    Parameter schema of a tool without calling it; omit \`name\` to list tool names.
-    Use it before calling a tool you have not called before — a failed call also
-    returns the expected parameters, so fix the args and retry in the next cell
-    instead of abandoning eval.
+    Parameter schema of a tool (omit \`name\` to list tool names); a failed \`tool.<name>()\` call also returns the expected parameters.
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
-    Oneshot, stateless (no history/tools). \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → structured output, parsed object.
+    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 another discovered agent; omit it to use \`{{spawnDefaultAgent}}\`. \`schema\` as in completion(). Background via \`local://\` files named in the prompt. \`handle\` → workflow node dict { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` when \`schema\` set).
-{{#if js}}    JS: options are ONE trailing object — agent(prompt, { agent, schema, handle }).
-{{/if}}{{/if}}parallel(thunks) → list
-    Thunks through a bounded pool (wide as a \`task\` batch — don't pre-shrink), input order kept; returns when all finish, a throwing thunk propagates.
+    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
+    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 left-to-right, barrier between stages; stage 1 gets the item, later stages the previous result.
+    Map items through one-arg stages with a barrier between stages; each stage receives the previous stage's result.
 log(message) → None
     Progress line above the status tree.
 phase(title) → None
@@ -190,18 +143,10 @@ phase(title) → None
 </prelude>
 {{#if spawns}}
 <workflow>
-Define the workflow spec IN CODE: partition the work into logically distinct steps, one node per step, then wire them as acyclic waves — never hand-author the graph as a single opaque call.
-- **Name nodes.** Capture each \`agent(…, {{#if py}}handle=True{{/if}}{{#if js}}{ handle: true }{{/if}}{{#if jl}}handle=true{{/if}})\` result; carries \`handle\` (\`agent://<id>\`) + \`output\`.
-- **Wire edges by reference.** Put an upstream node's \`handle\`/\`output\` in the dependent stage's prompt — large transcript never re-inlined. Bulk: \`write("local://<name>.md", …)\`, pass the URI.
-- **\`pipeline(items, *stages)\` = staged waves**, barrier between stages (every item clears stage N before any enters N+1). **\`parallel(thunks)\` = one wave** of independent nodes.
-- **Isolate failure.** A raising node re-raises the lowest-index error, aborts its wave; wrap risky nodes in try/except so a failure degrades only its dependent subtree, independent branches finish.
-- **Acyclic only.** A node never waits on its own descendant.
+Multi-agent work is an acyclic graph in code: one \`agent(…)\` node per step with its handle option ({{#if py}}\`handle=True\`{{/if}}{{#ifAll py js}} / {{/ifAll}}{{#if js}}\`{ handle: true }\`{{/if}}{{#if jl}}{{#ifAny py js}} / {{/ifAny}}\`handle=true\`{{/if}}), \`parallel(thunks)\` for independent nodes, \`pipeline(items, *stages)\` for staged waves. Pass an upstream node's \`handle\` or \`output\` (or a \`write("local://…")\` URI for bulk text) into dependents instead of re-inlining transcripts, and wrap risky nodes in try/except so a failure aborts only its subtree.
 </workflow>
 {{/if}}
-
-<critical>
-Prior top-level names (\`data\`, \`sessions\`, helpers, imports) survive into the next eval call — reuse them; NEVER re-import, re-require, or re-declare a helper. Re-read a file only if it may have changed since the last read.
-</critical>`;
+`;
 
 export function buildEvalPrompt(
 	enabled: EnabledLanguages,
@@ -230,20 +175,9 @@ export function buildEvalPrompt(
 		jsVersion: options.jsRuntime?.version ?? "",
 		bunSkillPath: options.bunSkillPath ?? "",
 	};
-	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
-		.map((example) => {
-			const call = { language: example.language, summary: example.summary, code: example.code };
-			return `### ${example.caption}\n\`\`\`json\n${JSON.stringify(call, null, 2)}\n\`\`\``;
-		})
-		.join("\n\n");
-	const description = [
-		renderTemplate(EVAL_PROMPT_TEMPLATE, context)
-			.replace(/\n{3,}/g, "\n\n")
-			.trim(),
-		examples === "" ? "" : `<examples>\n${examples}\n</examples>`,
-	]
-		.filter((part) => part !== "")
-		.join("\n\n");
+	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
 	return {
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",

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

@@ -17,6 +17,12 @@ export interface CellExecutionOptions {
 	readonly callerSignal: AbortSignal;
 	readonly cellId: string;
 	readonly timeoutMs: number;
+	/**
+	 * Caps how long a host-bridge pause may suspend the idle watchdog. When the cell will detach on
+	 * timeout this is set to the foreground window so a bridge-parked cell still frees the turn at the
+	 * window; left undefined (error mode) it keeps the idle-timeout default grace.
+	 */
+	readonly maxPauseGraceMs?: number;
 	readonly timeoutFactory: EvalTimeoutFactory;
 	readonly onTimeout: (error: Error) => void;
 	readonly onAbort: (error: Error) => void;
@@ -46,6 +52,7 @@ export class CellExecution {
 		this.#watchdog = options.timeoutFactory.create({
 			cellId: options.cellId,
 			timeoutMs: options.timeoutMs,
+			...(options.maxPauseGraceMs === undefined ? {} : { maxPauseGraceMs: options.maxPauseGraceMs }),
 			onTimeout: ({ error }) => options.onTimeout(error),
 		});
 		this.#callerSignal.addEventListener("abort", this.#handleCallerAbort, {

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

@@ -21,6 +21,12 @@ export interface CreateEvalToolOptions {
 	readonly enabledLanguages: EnabledEvalLanguages;
 	readonly kernelManager: EvalKernelManager;
 	readonly cellTimeoutSeconds: number;
+	/**
+	 * Longest an interactive (detach-behavior) call blocks the agent loop before the cell detaches,
+	 * capping the `timeout` detach budget. Defaults to {@link DEFAULT_FOREGROUND_WINDOW_SECONDS}.
+	 * Does not affect `on_timeout: "error"` calls or the wall-clock hard limit.
+	 */
+	readonly foregroundWindowSeconds?: number;
 	/** Wall-clock kill deadline applied to every cell; only used when this factory creates its own manager. */
 	readonly hardLimitSeconds?: number;
 	readonly executeTool: ExecuteTool;