@code-yeongyu/senpi-codemode 2026.8.23 → 2026.8.25

package/CHANGELOG.md

@@ -12,6 +12,32 @@
 
 ### Removed
 
+## [2026.8.25] - 2026-08-25
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.8.24] - 2026-08-24
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Detached eval cell overflow notices now point at the absolute spill file path (`…/local/detached-eval-<id>.log`) instead of a `local://detached-eval-<id>.log` URI. `local://` is resolved only by the in-cell kernel helpers, not by the agent `read` tool, so following the old notice failed with `ENOENT …/local:/detached-eval-<id>.log`. This restores the documented contract that spill notices carry plain absolute paths.
+
+### Removed
+
 ## [2026.8.23] - 2026-08-23
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.8.23",
+	"version": "2026.8.25",
 	"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.8.23",
-		"typebox": "1.3.16"
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.8.25",
+		"typebox": "1.3.18"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.8.23"
+		"@code-yeongyu/senpi": "2026.8.25"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.8.23"
+		"@code-yeongyu/senpi": "2026.8.25"
 	},
 	"keywords": [
 		"senpi",

package/src/extension/session-manager-proxy.ts

@@ -21,12 +21,30 @@ export class CodemodeSessionNotStartedError extends Error {
 	}
 }
 
+const defaultTeardownFailureReporter = (error: unknown): void => {
+	globalThis.process.stderr.write(`[senpi-codemode] ${describeTeardownFailure(error)}\n`);
+};
+
+function describeTeardownFailure(error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error);
+	if (error instanceof AggregateError && error.errors.length > 0) {
+		const causes = error.errors.map((cause) => (cause instanceof Error ? cause.message : String(cause))).join("; ");
+		return `session teardown failed: ${message} (${causes})`;
+	}
+	return `session teardown failed: ${message}`;
+}
+
 export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
 	#current: CodemodeSessionManager | undefined;
 	#generation = 0;
 	#started = false;
 	#acceptingExecutions = false;
 	readonly #executions = new Set<TrackedExecution>();
+	readonly #onTeardownFailure: (error: unknown) => void;
+
+	constructor(onTeardownFailure: (error: unknown) => void = defaultTeardownFailureReporter) {
+		this.#onTeardownFailure = onTeardownFailure;
+	}
 
 	beginReplacement(): number {
 		this.#generation++;
@@ -37,19 +55,19 @@ export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutio
 
 	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
 		if (generation !== this.#generation) {
-			await next.dispose();
+			await this.#disposeQuietly(next);
 			return false;
 		}
 		await this.#settleExecutions();
 		if (generation !== this.#generation) {
-			await next.dispose();
+			await this.#disposeQuietly(next);
 			return false;
 		}
 		const current = this.#current;
 		this.#current = undefined;
-		await current?.dispose();
+		await this.#disposeQuietly(current);
 		if (generation !== this.#generation) {
-			await next.dispose();
+			await this.#disposeQuietly(next);
 			return false;
 		}
 		this.#current = next;
@@ -100,7 +118,23 @@ export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutio
 		await this.#settleExecutions();
 		const current = this.#current;
 		this.#current = undefined;
-		await current?.dispose();
+		await this.#disposeQuietly(current);
+	}
+
+	/**
+	 * Session teardown is best-effort: a kernel or bridge that fails to confirm
+	 * close (e.g. a SIGKILLed interpreter missing its reap window throws
+	 * KernelRetirementError into the manager's dispose AggregateError) must not
+	 * reject the session lifecycle handler that triggered the teardown — the
+	 * extension host surfaces such rejections as user-facing extension errors.
+	 */
+	async #disposeQuietly(manager: CodemodeSessionManager | undefined): Promise<void> {
+		if (manager === undefined) return;
+		try {
+			await manager.dispose();
+		} catch (error) {
+			this.#onTeardownFailure(error);
+		}
 	}
 
 	#abortExecutions(): void {

package/src/kernels/AGENTS.md

@@ -0,0 +1,40 @@
+# src/kernels
+
+Persistent kernels for four runtimes plus shared subprocess lifecycle. Earned
+by score 13 — distinct multi-runtime domain (31 files, TS hosts plus embedded
+runner/prelude assets).
+
+## WHERE TO LOOK
+
+| Task | Path |
+| --- | --- |
+| JavaScript host API | `js/context-manager.ts` (`JavaScriptKernel`), `js/worker-host.ts` |
+| JS worker runtime, entries | `js/worker-runtime.js`, `js/worker-entry.js`, `js/inline-worker-entry.js`, `js/inline-worker.ts`, `js/worker-core.js` (+ `worker-core.d.ts`) |
+| JS import rewriting, queueing | `js/rewrite-imports.ts`, `js/run-queue.ts`, `js/prelude.ts`, `js/local-module-loader.ts` |
+| Python kernel | `py/kernel.ts`, `py/transport.ts`, `py/process.ts`, `py/prelude.py` |
+| Ruby kernel | `rb/kernel.ts` + `rb/prelude.rb`, `rb/runner.rb` |
+| Julia kernel | `jl/kernel.ts` + `jl/prelude.jl`, `jl/runner.jl` |
+| Shared subprocess layer | `shared/subprocess-kernel.ts`, `subprocess-{contract,process,queue,run}.ts`, `runtime-asset.ts` |
+
+## CONVENTIONS
+
+- Each language dir pairs a typed TS host/controller with an embedded runner or
+  prelude asset; `shared/runtime-asset.ts` ships them.
+- Transport messages are discriminated by string `type` (`ready`, `result`,
+  `tool-call`, `closed`, `init-failed`, ...) exchanged as framed bridge
+  messages, one JSON line per frame.
+- JS persistent cell bindings are rewritten onto `globalThis`; imports are
+  AST-parsed (Babel) and rewritten to bridge-compatible dynamic imports.
+- JS runs on worker threads with an inline-worker fallback; py/rb/jl run as
+  framed subprocesses through `shared/`.
+- Subprocess retirement/restart, worker recovery, timeout, and interrupt
+  semantics live here, never in the tool layer.
+
+## ANTI-PATTERNS
+
+- Never treat arbitrary objects as bridge messages without discriminant
+  validation.
+- Never rewrite imports by filename/regex — `rewrite-imports.ts` applies
+  source-position edits from the parsed program.
+- An optional interpreter being absent (py/rb/jl not installed) is a capability
+  gap, not an installation failure or error path.

package/src/tool/AGENTS.md

@@ -0,0 +1,40 @@
+# src/tool
+
+Eval tool core: input schema, cell execution lifecycle, detached-cell state
+machine, status events, and all call/result rendering. Earned by score 12 —
+highest reference density in the package (`createEvalTool` and `EvalToolDetails`
+anchor most suites).
+
+## WHERE TO LOOK
+
+| Task | Path |
+| --- | --- |
+| Tool registration, options | `eval-tool.ts`, `eval-tool-options.ts`, `eval-request.ts` |
+| Wire contract, TypeBox schemas | `types.ts` (`createEvalInputSchema`, `fullEvalInputSchema`) |
+| Cell execution, settlement | `cell-handler.ts`, `cell-execution.ts`, `cell-runtime.ts` |
+| Detached cells | `detached-cell-manager.ts` + `detached-cell-{state,snapshot,notification}.ts`, `detached-notification-queue.ts`, `detached-eval-result.ts` |
+| Call/result rendering | `render.ts`, `runtime-label.ts`, `json-tree.ts`, `image.ts`, `tool-widgets.ts` |
+| Status events, execution events | `status-events.ts`, `eval-execution-event.ts` |
+| Interrupt, capture | `interrupt-note.ts`, `call-capture.ts` |
+
+## CONVENTIONS
+
+- Wire/schema fields are snake_case (`cell_id`, `on_timeout`); internal TS
+  fields are camelCase. Schemas and shared eval types live only in `types.ts`.
+- Rendering is bounded by explicit line/code-point budgets with an injectable
+  render clock; nothing here depends on wall-clock luck.
+- Detached execution is a first-class state machine — snapshot, notification
+  queue, spill-file notice, result conversion — never folded into ordinary
+  cell execution.
+- Unicode tree glyphs and status icons are intentional UI conventions.
+
+## ANTI-PATTERNS
+
+- Never add unbounded output: previews, JSON tree depth/lines/scalar length,
+  widget lines, and collapsed errors all cap.
+- Never bypass the kernel bridge message contract with ad-hoc return values;
+  kernels import `KernelInterruptHandle` from `types.ts`, so discriminants and
+  lifecycle state are cross-runtime contracts — change them only with all four
+  runtimes and the detached path in mind.
+- `render.ts` (1,030 LOC) is the package's largest file and the highest-risk
+  hotspot for regressions; changes there need render contracts first.

package/src/tool/detached-cell-manager.ts

@@ -93,7 +93,7 @@ export class EvalDetachedCellManager {
 		this.#artifactsDir = options.artifactsDir;
 		this.#onStatusChange = options.onStatusChange;
 		this.#onWakeSourceState = options.onWakeSourceState;
-		this.#notificationQueue = new DetachedNotificationQueue(options.notifier, options.artifactsDir);
+		this.#notificationQueue = new DetachedNotificationQueue(options.notifier);
 		this.#now = options.now ?? Date.now;
 		this.#hardLimitSeconds = options.hardLimitSeconds ?? DEFAULT_HARD_LIMIT_SECONDS;
 	}

package/src/tool/detached-cell-notification.ts

@@ -12,7 +12,6 @@ export function detachedNotificationSpillPath(artifactsDir: string | undefined,
 export async function buildDetachedCellNotification(
 	snapshot: EvalDetachedCellSnapshot,
 	spillPath: string | undefined,
-	artifactsDir: string | undefined,
 ): Promise<EvalDetachedCellNotification> {
 	const body = notificationBody(snapshot);
 	const overflow = Buffer.byteLength(body, "utf8") > NOTIFICATION_TAIL_BYTES;
@@ -21,7 +20,9 @@ export async function buildDetachedCellNotification(
 		try {
 			await mkdir(dirname(spillPath), { recursive: true });
 			await writeFile(spillPath, body, "utf8");
-			spillNotice = `\nBuffered output overflowed; full output: ${localUri(spillPath, artifactsDir)}`;
+			// The agent read tool resolves plain paths only, so the notice must carry
+			// the absolute spill path, never the kernel-helper local:// scheme.
+			spillNotice = `\nBuffered output overflowed; full output: ${spillPath}`;
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			spillNotice = `\nBuffered output overflow could not be spilled: ${message}`;
@@ -84,12 +85,6 @@ function safeCellId(cellId: string): string {
 	return cellId.replace(/[^a-zA-Z0-9_-]/gu, "_");
 }
 
-function localUri(path: string, artifactsDir: string | undefined): string {
-	if (artifactsDir === undefined) return `local://${path}`;
-	const root = join(artifactsDir, "local");
-	return path.startsWith(`${root}/`) ? `local://${path.slice(root.length + 1)}` : `local://${path}`;
-}
-
 function truncateTailUtf8(text: string, maxBytes: number): string {
 	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
 	const bytes = Buffer.from(text, "utf8");

package/src/tool/detached-notification-queue.ts

@@ -7,14 +7,12 @@ export interface PendingDetachedNotification {
 }
 
 export class DetachedNotificationQueue {
-	readonly #artifactsDir: string | undefined;
 	readonly #notifier: EvalDetachedCellNotifier | undefined;
 	#pending: PendingDetachedNotification[] = [];
 	#flush: Promise<void> | undefined;
 
-	constructor(notifier: EvalDetachedCellNotifier | undefined, artifactsDir: string | undefined) {
+	constructor(notifier: EvalDetachedCellNotifier | undefined) {
 		this.#notifier = notifier;
-		this.#artifactsDir = artifactsDir;
 	}
 
 	enqueue(notification: PendingDetachedNotification): void {
@@ -32,9 +30,7 @@ export class DetachedNotificationQueue {
 		const flush = Promise.resolve().then(async () => {
 			const pending = this.#pending.splice(0);
 			const notifications = await Promise.all(
-				pending.map(
-					async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath, this.#artifactsDir),
-				),
+				pending.map(async (item) => await buildDetachedCellNotification(item.snapshot(), item.spillPath)),
 			);
 			this.#notifier?.notify(notifications);
 		});