@code-yeongyu/senpi 2026.7.11 → 2026.7.14-2

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

@@ -0,0 +1,296 @@
+import { createWriteStream, mkdirSync, type WriteStream } from "node:fs";
+import { dirname } from "node:path";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail } from "../host-sdk.ts";
+import { formatMiddleElisionMarker } from "./output-meta.ts";
+
+export { artifactNotice, formatMiddleElisionMarker, resolveSessionArtifactsDir } from "./output-meta.ts";
+export { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateTail };
+
+export const ARTIFACT_DEFAULT_HEAD_BYTES = 3 * 1024 * 1024;
+
+export interface OutputSummary {
+	readonly output: string;
+	readonly truncated: boolean;
+	readonly totalLines: number;
+	readonly totalBytes: number;
+	readonly outputLines: number;
+	readonly outputBytes: number;
+	readonly elidedBytes?: number;
+	readonly elidedLines?: number;
+	readonly columnDroppedBytes?: number;
+	readonly columnTruncatedLines?: number;
+	readonly artifactId?: string;
+}
+
+export interface OutputSinkOptions {
+	readonly artifactPath?: string;
+	readonly spillThreshold?: number;
+	readonly headBytes?: number;
+	readonly maxColumns?: number;
+	readonly onChunk?: (chunk: string) => void;
+	readonly chunkThrottleMs?: number;
+}
+
+interface ByteSlice {
+	readonly text: string;
+	readonly bytes: number;
+}
+
+function countNewlines(text: string): number {
+	let count = 0;
+	let cursor = text.indexOf("\n");
+	while (cursor !== -1) {
+		count++;
+		cursor = text.indexOf("\n", cursor + 1);
+	}
+	return count;
+}
+
+function lineCount(text: string): number {
+	return text.length === 0 ? 0 : countNewlines(text) + 1;
+}
+
+function truncateHeadBytes(text: string, maxBytes: number): ByteSlice {
+	if (maxBytes <= 0) return { text: "", bytes: 0 };
+	const buffer = Buffer.from(text, "utf8");
+	if (buffer.length <= maxBytes) return { text, bytes: buffer.length };
+	let end = maxBytes;
+	while (end > 0 && (buffer[end] & 0xc0) === 0x80) end--;
+	const slice = buffer.subarray(0, end);
+	return { text: slice.toString("utf8"), bytes: slice.length };
+}
+
+function truncateTailBytes(text: string, maxBytes: number): ByteSlice {
+	if (maxBytes <= 0) return { text: "", bytes: 0 };
+	const buffer = Buffer.from(text, "utf8");
+	if (buffer.length <= maxBytes) return { text, bytes: buffer.length };
+	let start = buffer.length - maxBytes;
+	while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start++;
+	const slice = buffer.subarray(start);
+	return { text: slice.toString("utf8"), bytes: slice.length };
+}
+
+export class TailBuffer {
+	readonly #maxBytes: number;
+	#text = "";
+	#bytes = 0;
+
+	constructor(maxBytes: number) {
+		this.#maxBytes = Math.max(0, Math.floor(maxBytes));
+	}
+
+	append(text: string): void {
+		if (text.length === 0) return;
+		if (this.#maxBytes === 0) {
+			this.#text = "";
+			this.#bytes = 0;
+			return;
+		}
+		const incomingBytes = Buffer.byteLength(text, "utf8");
+		const next =
+			incomingBytes >= this.#maxBytes
+				? truncateTailBytes(text, this.#maxBytes)
+				: truncateTailBytes(this.#text + text, this.#maxBytes);
+		this.#text = next.text;
+		this.#bytes = next.bytes;
+	}
+
+	text(): string {
+		return this.#text;
+	}
+
+	bytes(): number {
+		return this.#bytes;
+	}
+}
+
+export class OutputSink {
+	readonly #artifactPath: string | undefined;
+	readonly #spillThreshold: number;
+	readonly #headLimit: number;
+	readonly #maxColumns: number;
+	readonly #onChunk: ((chunk: string) => void) | undefined;
+	readonly #chunkThrottleMs: number;
+	readonly #tail: TailBuffer;
+	#head = "";
+	#headBytes = 0;
+	#totalNewlines = 0;
+	#totalBytes = 0;
+	#sawData = false;
+	#truncated = false;
+	#currentLineBytes = 0;
+	#columnCapped = false;
+	#columnDroppedBytes = 0;
+	#columnTruncatedLines = 0;
+	#lastChunkTime = 0;
+	#pendingChunk = "";
+	#beforeSpill = "";
+	#file: WriteStream | undefined;
+	#fileError: Error | undefined;
+	#dumpPromise: Promise<OutputSummary> | undefined;
+
+	constructor(options: OutputSinkOptions = {}) {
+		this.#artifactPath = options.artifactPath;
+		this.#spillThreshold = Math.max(0, Math.floor(options.spillThreshold ?? DEFAULT_MAX_BYTES));
+		this.#headLimit = Math.max(0, Math.floor(options.headBytes ?? 0));
+		this.#maxColumns = Math.max(0, Math.floor(options.maxColumns ?? 0));
+		this.#onChunk = options.onChunk;
+		this.#chunkThrottleMs = Math.max(0, Math.floor(options.chunkThrottleMs ?? 0));
+		this.#tail = new TailBuffer(this.#spillThreshold);
+	}
+
+	push(chunk: string): void {
+		if (chunk.length === 0) return;
+		this.#emitPreview(chunk);
+		const rawBytes = Buffer.byteLength(chunk, "utf8");
+		this.#totalBytes += rawBytes;
+		this.#totalNewlines += countNewlines(chunk);
+		this.#sawData = true;
+		this.#mirrorRaw(chunk);
+		this.#retain(this.#maxColumns > 0 ? this.#clampColumns(chunk) : chunk);
+	}
+
+	dump(notice?: string): Promise<OutputSummary> {
+		this.#dumpPromise ??= this.#finishDump(notice);
+		return this.#dumpPromise;
+	}
+
+	#emitPreview(chunk: string): void {
+		if (this.#onChunk === undefined) return;
+		const now = Date.now();
+		if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
+			this.#lastChunkTime = now;
+			this.#onChunk(this.#pendingChunk + chunk);
+			this.#pendingChunk = "";
+			return;
+		}
+		this.#pendingChunk += chunk;
+	}
+
+	#mirrorRaw(chunk: string): void {
+		if (this.#artifactPath === undefined) return;
+		if (this.#file !== undefined) {
+			this.#file.write(chunk);
+			return;
+		}
+		if (this.#totalBytes <= this.#spillThreshold) {
+			this.#beforeSpill += chunk;
+			return;
+		}
+		mkdirSync(dirname(this.#artifactPath), { recursive: true });
+		const stream = createWriteStream(this.#artifactPath, { encoding: "utf8" });
+		stream.on("error", (error) => {
+			this.#fileError = error;
+		});
+		this.#file = stream;
+		if (this.#beforeSpill.length > 0) stream.write(this.#beforeSpill);
+		this.#beforeSpill = "";
+		stream.write(chunk);
+	}
+
+	#retain(text: string): void {
+		let tailText = text;
+		if (this.#headBytes < this.#headLimit) {
+			const head = truncateHeadBytes(text, this.#headLimit - this.#headBytes);
+			this.#head += head.text;
+			this.#headBytes += head.bytes;
+			tailText = text.substring(head.text.length);
+		}
+		this.#tail.append(tailText);
+		const effectiveBytes = this.#totalBytes - this.#columnDroppedBytes;
+		if (effectiveBytes > this.#headBytes + this.#tail.bytes()) this.#truncated = true;
+	}
+
+	#clampColumns(chunk: string): string {
+		const output: string[] = [];
+		let cursor = 0;
+		while (cursor < chunk.length) {
+			const newline = chunk.indexOf("\n", cursor);
+			const end = newline === -1 ? chunk.length : newline;
+			const segment = chunk.substring(cursor, end);
+			if (segment.length > 0) {
+				const segmentBytes = Buffer.byteLength(segment, "utf8");
+				if (this.#columnCapped) {
+					this.#columnDroppedBytes += segmentBytes;
+				} else {
+					const remaining = Math.max(0, this.#maxColumns - this.#currentLineBytes);
+					const kept = truncateHeadBytes(segment, remaining);
+					output.push(kept.text);
+					this.#currentLineBytes += kept.bytes;
+					if (kept.bytes < segmentBytes) {
+						output.push("…");
+						this.#columnDroppedBytes += segmentBytes - kept.bytes;
+						this.#columnTruncatedLines++;
+						this.#columnCapped = true;
+						this.#truncated = true;
+					}
+				}
+			}
+			if (newline === -1) break;
+			output.push("\n");
+			this.#currentLineBytes = 0;
+			this.#columnCapped = false;
+			cursor = newline + 1;
+		}
+		return output.join("");
+	}
+
+	async #finishDump(notice: string | undefined): Promise<OutputSummary> {
+		if (this.#onChunk !== undefined && this.#pendingChunk.length > 0) {
+			this.#onChunk(this.#pendingChunk);
+			this.#pendingChunk = "";
+		}
+		await this.#closeFile();
+		let tail = this.#tail.text();
+		if (lineCount(tail) > DEFAULT_MAX_LINES) {
+			tail = truncateTail(tail, { maxLines: DEFAULT_MAX_LINES, maxBytes: Number.MAX_SAFE_INTEGER }).content;
+			this.#truncated = true;
+		}
+		const totalLines = this.#sawData ? this.#totalNewlines + 1 : 0;
+		const tailBytes = Buffer.byteLength(tail, "utf8");
+		const effectiveBytes = Math.max(0, this.#totalBytes - this.#columnDroppedBytes);
+		let body = this.#head + tail;
+		let elidedBytes: number | undefined;
+		let elidedLines: number | undefined;
+		if (this.#headBytes > 0 && effectiveBytes > this.#headBytes + tailBytes) {
+			elidedBytes = effectiveBytes - this.#headBytes - tailBytes;
+			elidedLines = Math.max(0, totalLines - lineCount(this.#head) - lineCount(tail));
+			const headSeparator = this.#head.endsWith("\n") ? "" : "\n";
+			const tailSeparator = tail.length === 0 || tail.startsWith("\n") ? "" : "\n";
+			body = `${this.#head}${headSeparator}${formatMiddleElisionMarker(elidedLines, elidedBytes)}${tailSeparator}${tail}`;
+			this.#truncated = true;
+		}
+		return {
+			output: notice === undefined ? body : `[${notice}]\n${body}`,
+			truncated: this.#truncated,
+			totalLines,
+			totalBytes: this.#totalBytes,
+			outputLines: lineCount(body),
+			outputBytes: Buffer.byteLength(body, "utf8"),
+			elidedBytes,
+			elidedLines,
+			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
+			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
+			artifactId: this.#file === undefined ? undefined : this.#artifactPath,
+		};
+	}
+
+	async #closeFile(): Promise<void> {
+		const stream = this.#file;
+		if (stream === undefined) return;
+		if (this.#fileError !== undefined) throw this.#fileError;
+		await new Promise<void>((resolve, reject) => {
+			const onError = (error: Error) => {
+				stream.off("finish", onFinish);
+				reject(error);
+			};
+			const onFinish = () => {
+				stream.off("error", onError);
+				resolve();
+			};
+			stream.once("error", onError);
+			stream.once("finish", onFinish);
+			stream.end();
+		});
+	}
+}

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

@@ -11,76 +11,146 @@ export interface EvalPromptParts {
 	readonly promptGuidelines: readonly string[];
 }
 
+export interface EvalPromptOptions {
+	readonly spawns: boolean;
+	readonly spawnDefaultAgent?: string;
+}
+
 type ContextValue = string | boolean;
 type Context = Readonly<Record<string, ContextValue>>;
+type EvalPromptExample = {
+	readonly caption: string;
+	readonly language: keyof EnabledLanguages;
+	readonly title: 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: "py",
+		title: "collect targets",
+		code: "from pathlib import Path\nfrom collections import Counter\nfiles = [p for p in Path('src').rglob('*.ts') if 'test' not in p.parts]\nprint(len(files))",
+	},
+	{
+		caption: "Second call — reuse `files`, batch-read in one cell",
+		language: "py",
+		title: "scan usages",
+		code: "hits = Counter()\nfor p in files:\n    hits[p.name] = read(p).count('legacyClient')\ndisplay({k: v for k, v in hits.items() if v})",
+	},
+	{
+		caption: "Third call — reuse results, fan out session tools in parallel",
+		language: "py",
+		title: "confirm callsites",
+		code: "dirs = ['src/core', 'src/tools']\ndisplay(parallel([lambda d=d: tool.grep({'pattern': 'legacyClient', 'path': d}) for d in dirs]))",
+	},
+] 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 — define helpers, datasets, and clients in one call, then later calls reuse them directly.
+**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.
 
-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. Parallelize work *within* a cell with the \`parallel(thunks)\` helper, not by batching steps.
+**Batch through eval.** One cell replaces many one-shot tool calls: loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time, post-process \`tool.<name>()\` results programmatically, and fan independent calls through \`parallel(thunks)\` within the cell — never one call per turn.
 
 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.
 - \`title\` (optional) — short transcript label (e.g. \`"imports"\`).
-- \`timeout\` (optional) — seconds. Raise only for heavy compute or long delegated tool calls.
+- \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
 - \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
 
-{{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(...)\` raises "cannot be called from a running event loop".{{/if}}
+{{#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 rb}}Ruby: synchronous; helper options are keyword args; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition.{{/if}}
-{{#if jl}}Julia: synchronous; helper options are standard keyword args; the last expression auto-displays unless it is an assignment or a definition.{{/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 — prior calls' state survives.
 </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.{{else}}{{#if py}}Sync; options = trailing kwargs.{{/if}}{{#if js}}Async/\`await\`able; options = ONE trailing object literal, never positional.{{/if}}{{/ifAll}}{{#if rb}} Ruby: sync, options = trailing keyword args.{{/if}}{{#if jl}} Julia: sync, options = trailing keyword args.{{/if}}
+{{#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 result; figures/images/dataframes shown natively.
-print(value, ...) -> None
-    Text stream.
-read(path, offset?=1, limit?=None) -> str
-    File as text; offset/limit are 1-indexed lines.
-write(path, content) -> str
-    Write file, creating parents, and return the resolved path.
-env(key?=None, value?=None) -> str | None | dict
-    No args -> full env dict; one -> value of key; two -> set key=value and return value.
-tool.<name>(args) -> unknown
-    Invoke any active session tool; args = its parameter object.
-completion(prompt, model?="default", system?=None, schema?=None) -> str | dict
-    Oneshot, stateless completion. model "default" uses the session model; schema is JSON Schema for structured results.
-parallel(thunks) -> list
-    Thunks through a bounded pool, input order kept; returns when all finish, a throwing thunk propagates.
-pipeline(items, ...stages) -> list
+display(value) → None
+    Cell output; figures/images/dataframes shown natively.
+print(value, ...) → None
+    Text output.
+read(path, offset?=1, limit?=None) → str
+    File as text; offset/limit are 1-indexed lines. Accepts \`local://…\`.
+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.
+{{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
+    Task/agent output by id. \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
+{{/if}}tool.<name>(args) → unknown
+    Invoke any session tool; \`args\` = its parameter object.
+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.
+{{#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\` → DAG 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.
+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.
-log(message) -> None
+log(message) → None
     Progress line above the status tree.
-phase(title) -> None
+phase(title) → None
     Phase grouping subsequent status lines.
 \`\`\`
 </prelude>
+{{#if spawns}}
+<dag>
+Pipe handles through stage helpers to build a dependency graph — acyclic waves:
+- **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.
+</dag>
+{{/if}}
 
 <critical>
-Prior top-level names 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. Re-run setup only after \`reset\`, a crash, or a \`NameError\`/\`ReferenceError\`.
+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): EvalPromptParts {
+export function buildEvalPrompt(
+	enabled: EnabledLanguages,
+	options: EvalPromptOptions = { spawns: false },
+): EvalPromptParts {
 	if (!enabled.py && !enabled.js && !enabled.rb && !enabled.jl) {
 		throw new Error("no kernels enabled for eval prompt");
 	}
+	const spawnDefaultAgent = options.spawnDefaultAgent ?? "task";
 	const context: Context = {
 		py: enabled.py,
 		js: enabled.js,
 		rb: enabled.rb,
 		jl: enabled.jl,
+		spawns: options.spawns,
+		spawnDefaultAgent,
 	};
-	const description = renderTemplate(EVAL_PROMPT_TEMPLATE, context)
-		.replace(/\n{3,}/g, "\n\n")
-		.trim();
+	const examples = REUSE_CHAIN_EXAMPLES.filter((example) => enabled[example.language])
+		.map((example) => {
+			const call = { language: example.language, title: example.title, 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");
 	return {
 		description,
 		promptSnippet: "Run one incremental code cell in a persistent language kernel.",

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

@@ -1,3 +1,5 @@
+export { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../bridge/reserved.ts";
+
 import type { TimeoutPauseHandle } from "./idle-timeout.ts";
 
 export async function withBridgeTimeoutPause<T>(

package/node_modules/@code-yeongyu/senpi-codemode/src/timeouts/idle-timeout.ts

@@ -16,10 +16,10 @@ export interface TimeoutPauseHandle {
 
 export class IdleTimeout implements TimeoutPauseHandle {
 	readonly #cellId: string;
-	readonly #timeoutMs: number;
 	readonly #onTimeout: (event: IdleTimeoutEvent) => void;
 	readonly #controller = new AbortController();
-	#remainingMs: number;
+	readonly signal = this.#controller.signal;
+	readonly timeoutMs: number;
 	#deadlineMs: number;
 	#timer: ReturnType<typeof setTimeout> | undefined;
 	#pauseDepth = 0;
@@ -27,26 +27,16 @@ export class IdleTimeout implements TimeoutPauseHandle {
 
 	constructor(options: IdleTimeoutOptions) {
 		this.#cellId = options.cellId;
-		this.#timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
-		this.#remainingMs = this.#timeoutMs;
-		this.#deadlineMs = Date.now() + this.#remainingMs;
+		this.timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
+		this.#deadlineMs = Date.now() + this.timeoutMs;
 		this.#onTimeout = options.onTimeout;
-		this.#arm(this.#remainingMs);
-	}
-
-	get signal(): AbortSignal {
-		return this.#controller.signal;
-	}
-
-	get timeoutMs(): number {
-		return this.#timeoutMs;
+		this.#arm(this.timeoutMs);
 	}
 
 	pause(): void {
 		if (this.#settled) return;
 		this.#pauseDepth++;
 		if (this.#pauseDepth !== 1) return;
-		this.#remainingMs = Math.max(0, this.#deadlineMs - Date.now());
 		this.#clearTimer();
 	}
 
@@ -54,8 +44,8 @@ export class IdleTimeout implements TimeoutPauseHandle {
 		if (this.#settled || this.#pauseDepth === 0) return;
 		this.#pauseDepth--;
 		if (this.#pauseDepth > 0) return;
-		this.#deadlineMs = Date.now() + this.#remainingMs;
-		this.#arm(this.#remainingMs);
+		this.#deadlineMs = Date.now() + this.timeoutMs;
+		this.#arm(this.timeoutMs);
 	}
 
 	dispose(): void {
@@ -81,13 +71,12 @@ export class IdleTimeout implements TimeoutPauseHandle {
 		if (this.#settled || this.#pauseDepth > 0) return;
 		const remainingMs = this.#deadlineMs - Date.now();
 		if (remainingMs > 0) {
-			this.#remainingMs = remainingMs;
 			this.#arm(remainingMs);
 			return;
 		}
 		this.#settled = true;
 		this.#timer = undefined;
-		const error = new Error(`Cell timed out after ${this.#timeoutMs}ms`);
+		const error = new Error(`Cell timed out after ${this.timeoutMs}ms`);
 		error.name = "TimeoutError";
 		this.#controller.abort(error);
 		this.#onTimeout({ cellId: this.#cellId, error });