pi-crew 0.9.44 → 0.9.46

package/src/state/run-metrics.ts

@@ -107,6 +107,16 @@ export function loadRunMetrics(cwd: string, runId: string): RunMetrics | undefin
  * List recent metrics files up to `limit` entries (newest first).
  * Returns an array of { runId, timestamp, taskCount, completedCount, failedCount, totalTokens, totalCost, durationMs, consistencyScore }.
  * Gracefully skips files that cannot be read or parsed.
+ *
+ * FIND-04 perf: sort dirents by mtime descending BEFORE reading any of
+ * them, then read at most `limit` files. Malformed files within that
+ * selected window reduce the returned count; the scan does not continue
+ * past the window to backfill them. Previously the function read up
+ * to MAX_METRIC_FILES_TO_SCAN (500) files via loadRunMetrics() and only
+ * THEN sorted+sliced to `limit` (default 25) — wasting 475 readFileSync +
+ * JSON.parse calls on the hot dashboard path. The sort is O(N log N) and
+ * uses the run-id timestamp prefix as a cheap secondary signal when
+ * mtimes tie (e.g. multiple files saved in the same millisecond).
  */
 export function getRunMetricsSummary(cwd: string, limit = 25): RunMetrics[] {
 	const dir = metricsDir(cwd);
@@ -117,21 +127,39 @@ export function getRunMetricsSummary(cwd: string, limit = 25): RunMetrics[] {
 		return [];
 	}
 
+	// Cap the directory-order candidate set before collecting mtimes. This
+	// is a safety valve against unbounded scan cost; the mtime sort below
+	// only reorders entries within this bounded candidate window.
+	const cap = Math.max(0, limit);
+	const sorted = entries
+		.filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+		.slice(0, MAX_METRIC_FILES_TO_SCAN)
+		.map((entry) => {
+			const fullPath = path.join(dir, entry.name);
+			let mtimeMs = 0;
+			try {
+				mtimeMs = fs.statSync(fullPath).mtimeMs;
+			} catch {
+				// stat failure: fall through with mtimeMs=0; the sort still
+				// produces a deterministic order (filenames tiebreak).
+			}
+			return { name: entry.name, mtimeMs };
+		})
+		.sort((a, b) => {
+			const diff = b.mtimeMs - a.mtimeMs;
+			if (diff !== 0) return diff;
+			// Filename tiebreaker: the run-id prefix is a YYYYMMDDhhmmss
+			// timestamp (e.g. team_20260720050617_abc123) so a descending
+			// string compare yields newest-first within a tie group.
+			return b.name.localeCompare(a.name);
+		});
+
 	const metrics: RunMetrics[] = [];
-	for (const entry of entries) {
-		if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-		const runId = entry.name.replace(/\.json$/, "");
+	for (const { name } of sorted.slice(0, cap)) {
+		const runId = name.replace(/\.json$/, "");
 		const m = loadRunMetrics(cwd, runId);
 		if (m) metrics.push(m);
-		if (metrics.length >= MAX_METRIC_FILES_TO_SCAN) break;
 	}
 
-	// Sort newest first (by timestamp, then runId as tiebreaker).
-	metrics.sort((a, b) => {
-		const diff = new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
-		if (diff !== 0) return diff;
-		return b.runId.localeCompare(a.runId);
-	});
-
-	return metrics.slice(0, limit);
+	return metrics;
 }

package/src/ui/live-run-sidebar.ts

@@ -8,7 +8,6 @@ import type { TeamTaskState } from "../state/types.ts";
 import { aggregateUsage, formatUsage } from "../state/usage.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
 import { pad, truncate } from "../utils/visual.ts";
-import { Box, Text } from "./layout-primitives.ts";
 import { RenderScheduler } from "./render-scheduler.ts";
 import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
@@ -16,17 +15,10 @@ import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { colorizeStatusGlyphs, iconForStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
+import { renderLines } from "./widget/widget-renderer.ts";
 
 const TASK_READ_TTL_MS = 200;
 
-function renderLines(lines: string[], width: number): string[] {
-	const box = new Box(0, 0);
-	for (const line of lines) {
-		box.addChild(new Text(line));
-	}
-	return box.render(width);
-}
-
 type Done = (value: undefined) => void;
 
 function line(text: string, width: number): string {

package/src/ui/run-dashboard.ts

@@ -19,7 +19,6 @@ import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
 import { dashboardActionForKey } from "./keybinding-map.ts";
-import { Box, Text } from "./layout-primitives.ts";
 import { HelpOverlay } from "./overlays/help-overlay.ts";
 import { RenderScheduler } from "./render-scheduler.ts";
 import { runEventBusAsRenderScheduler } from "./run-event-bus.ts";
@@ -28,6 +27,7 @@ import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { applyStatusColor, colorizeStatusGlyphs, iconForStatus, type RunStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
+import { renderLines } from "./widget/widget-renderer.ts";
 
 /** S05 — wrap a pane render in try/catch so a single pane crash does not bring down the whole dashboard. */
 function safeRenderPane(name: string, fn: () => string[]): string[] {
@@ -159,14 +159,6 @@ function formatAge(iso: string | undefined): string | undefined {
 	return `${Math.floor(ms / 3_600_000)}h`;
 }
 
-function renderLines(lines: string[], width: number): string[] {
-	const box = new Box(0, 0);
-	for (const line of lines) {
-		box.addChild(new Text(line));
-	}
-	return box.render(width);
-}
-
 function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache): string[] {
 	// P0-6: prefer the snapshot's `recentOutputLines` (no disk I/O) over reading the
 	// progress artifact on every render. The progress artifact content is captured

package/src/utils/incremental-reader.ts

@@ -13,6 +13,111 @@ export interface IncrementalReadResult {
 
 const CHUNK_SIZE = 64 * 1024;
 
+/**
+ * Read the last `tailBytes` bytes of a file and parse it as JSONL,
+ * returning each successfully-parsed item in file order. If the file is
+ * shorter than `tailBytes`, the entire file is read from offset 0.
+ *
+ * Returns:
+ *   - items: parsed JSONL items (T may be any deserializable type)
+ *   - fileSize: total file size in bytes
+ *   - bytesRead: number of bytes actually read (≤ min(fileSize, tailBytes))
+ *   - truncated: true when `bytesRead < fileSize` (a prefix was dropped)
+ *
+ * The function bounds the read to `tailBytes`, so CPU is O(tail bytes)
+ * regardless of how large the file grows. Used by the event-log tail
+ * read path (FIND-05) to avoid the O(total events) cost of the legacy
+ * `readFileSync`+`split("\n")`+`JSON.parse` approach.
+ */
+export function readJsonlTail<T>(
+	filePath: string,
+	tailBytes: number,
+): {
+	items: T[];
+	fileSize: number;
+	bytesRead: number;
+	truncated: boolean;
+} {
+	const limit = Math.max(0, Math.floor(tailBytes));
+	let stat: fs.Stats;
+	try {
+		stat = fs.statSync(filePath);
+	} catch {
+		return { items: [], fileSize: 0, bytesRead: 0, truncated: false };
+	}
+	const fileSize = stat.size;
+	if (fileSize === 0 || limit === 0) {
+		return { items: [], fileSize, bytesRead: 0, truncated: false };
+	}
+
+	const startOffset = Math.max(0, fileSize - limit);
+	const bytesToRead = fileSize - startOffset;
+	const truncated = startOffset > 0;
+
+	let fd: number | undefined;
+	try {
+		// FIND-05 follow-up: O_NOFOLLOW refuses symlinks (defense-in-depth,
+		// consistent with atomicWriteFile / resolveRealContainedPath). The
+		// eventsPath is validated inside stateRoot, but this guards against a
+		// symlinked file appearing after validation. O_NOFOLLOW on a symlink
+		// yields ELOOP, which the catch below treats like ENOENT (return empty).
+		fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+	} catch {
+		return { items: [], fileSize, bytesRead: 0, truncated: false };
+	}
+	try {
+		const buf = Buffer.alloc(bytesToRead);
+		let totalRead = 0;
+		while (totalRead < bytesToRead) {
+			const chunkSize = Math.min(CHUNK_SIZE, bytesToRead - totalRead);
+			const bytesRead = fs.readSync(fd, buf, totalRead, chunkSize, startOffset + totalRead);
+			if (bytesRead === 0) break;
+			totalRead += bytesRead;
+		}
+
+		// Decode the slice we actually read; the buffer may be partially
+		// filled on short reads. We use totalRead (not bytesToRead) so the
+		// JSONL split lands on actual data, not a zero-padded tail.
+		const content = buf.toString("utf-8", 0, totalRead);
+
+		// If we truncated the file, the first decoded line may be a
+		// half-line from the cut. Drop it — we can't trust the JSON.
+		// Use a single indexOf("\n") to find the first newline; if there
+		// is none, the whole tail is one partial line and we drop it.
+		let body = content;
+		if (truncated) {
+			const firstNewline = body.indexOf("\n");
+			if (firstNewline < 0) {
+				// No newline at all in the tail → the entire tail is one
+				// partial line. Return no items; the caller should fall
+				// back to a wider tail or full read.
+				return { items: [], fileSize, bytesRead: totalRead, truncated: true };
+			}
+			body = body.slice(firstNewline + 1);
+		}
+
+		const items: T[] = [];
+		for (const line of body.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				items.push(JSON.parse(trimmed) as T);
+			} catch {
+				// Skip malformed lines (mirrors readJsonlSince's behavior).
+			}
+		}
+		return { items, fileSize, bytesRead: totalRead, truncated };
+	} finally {
+		if (fd !== undefined) {
+			try {
+				fs.closeSync(fd);
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+}
+
 /**
  * Read new lines from a text file since last known byte offset.
  * Uses fs.openSync + fs.readSync for efficient incremental reading.

package/src/utils/visual.ts

@@ -1,98 +1,28 @@
+import { visibleWidth as tuiVisibleWidth } from "@earendil-works/pi-tui";
+
 export const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
 
 const WIDTH_CACHE_LIMIT = 256;
 const widthCache = new Map<string, number>();
 
-/** Code-point ranges that render as width 2 in most terminals (CJK + emoji). */
-const WIDE_RANGES: Array<[number, number]> = [
-	// CJK Unified Ideographs
-	[0x4e00, 0x9fff],
-	// CJK Extension A
-	[0x3400, 0x4dbf],
-	// CJK Compatibility Ideographs
-	[0xf900, 0xfaff],
-	// Hangul Syllables
-	[0xac00, 0xd7af],
-	// CJK Symbols and Punctuation, Hiragana, Katakana
-	[0x3000, 0x33ff],
-	// Fullwidth forms
-	[0xff01, 0xff60],
-	// Emoji blocks
-	// Emoji-presentation codepoints in 0x2600-0x27BF (narrow chars like ✓✗★ excluded)
-	[0x2615, 0x2615],
-	[0x2648, 0x2653],
-	[0x267f, 0x267f],
-	[0x2693, 0x2693],
-	[0x26a1, 0x26a1],
-	[0x26aa, 0x26ab],
-	[0x26bd, 0x26be],
-	[0x26c4, 0x26c5],
-	[0x26ce, 0x26ce],
-	[0x26d4, 0x26d4],
-	[0x26ea, 0x26ea],
-	[0x26f2, 0x26f3],
-	[0x26f5, 0x26f5],
-	[0x26fa, 0x26fa],
-	[0x26fd, 0x26fd],
-	[0x2702, 0x2702],
-	[0x2705, 0x2705],
-	[0x2708, 0x270d],
-	[0x270f, 0x270f],
-	[0x2712, 0x2712],
-	[0x2714, 0x2714],
-	[0x2716, 0x2716],
-	[0x271d, 0x271d],
-	[0x2721, 0x2721],
-	[0x2728, 0x2728],
-	[0x2733, 0x2734],
-	[0x2744, 0x2744],
-	[0x2747, 0x2747],
-	[0x274c, 0x274c],
-	[0x274e, 0x274e],
-	[0x2753, 0x2755],
-	[0x2757, 0x2757],
-	[0x2763, 0x2764],
-	[0x2795, 0x2797],
-	[0x27a1, 0x27a1],
-	[0x27b0, 0x27b0],
-	[0x27bf, 0x27bf],
-	// Geometric Shapes / Misc Symbols-Arrows emoji that pi-tui upstream counts as
-	// width=2 (RGI emoji). Mismatch here caused the "Rendered line N exceeds
-	// terminal width (160 > 159)" TUI crash: pi-crew truncated to width 159 by
-	// its own (mismatched) measure, then Box padded to 159 chars, but pi-tui
-	// re-measured the padded line at 160 because ⬜ counts as 2 upstream.
-	[0x2b1b, 0x2b1c], // ⬛ BLACK LARGE SQUARE, ⬜ WHITE LARGE SQUARE
-	[0x1f300, 0x1f9ff], // Misc Symbols, Emoticons, Transport, Map, Supplement
-	[0x1fa00, 0x1faff], // Symbols Extended-A
-	[0x1f000, 0x1f02f], // Mahjong, Dominos
-	[0xfe00, 0xfe0f], // Variation Selectors (emoji presentation)
-];
-// NOTE: U+200D (Zero Width Joiner, ZWJ) is intentionally NOT listed as wide.
-// ZWJ has zero advance width by Unicode definition; miscounting it as 2 caused
-// slight over-truncation/over-padding of compound-emoji goals (T-1).
-
-function isWideCodePoint(code: number): boolean {
-	for (const [lo, hi] of WIDE_RANGES) {
-		if (code >= lo && code <= hi) return true;
-	}
-	return false;
-}
+// NOTE: width measurement is delegated to pi-tui's `visibleWidth` (see below).
+// pi-tui is the renderer that HARD-ABORTS the session if any line exceeds the
+// terminal width by ITS measure, so our truncate/pad/wrap MUST agree with it.
+// A previous hand-maintained WIDE_RANGES table diverged from pi-tui's
+// grapheme+RGI-emoji model on codepoints like ⏳ U+23F3 (hourglass: we counted
+// 1, pi-tui counts 2) → lines we believed fit were rejected →
+// "Rendered line N exceeds terminal width (160 > 159)" crash. Delegating makes
+// divergence structurally impossible.
 
 export function visibleWidth(value: string): number {
-	// Skip caching for very long strings to avoid memory pressure.
-	if (value.length > 4096) {
-		let length = 0;
-		for (const char of value.replace(ANSI_PATTERN, "")) {
-			if (char !== "\n") length += isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1;
-		}
-		return length;
-	}
+	// Delegate to pi-tui's authoritative width model so our truncate/pad/wrap
+	// can never disagree with the renderer's doRender measurement. Keep our own
+	// LRU cache on top (pi-tui caches too, but this avoids repeated calls for the
+	// hot render path).
+	if (value.length > 4096) return tuiVisibleWidth(value);
 	const cached = widthCache.get(value);
 	if (cached !== undefined) return cached;
-	let length = 0;
-	for (const char of value.replace(ANSI_PATTERN, "")) {
-		if (char !== "\n") length += isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1;
-	}
+	const length = tuiVisibleWidth(value);
 	if (widthCache.size >= WIDTH_CACHE_LIMIT) {
 		const firstKey = widthCache.keys().next().value;
 		if (firstKey !== undefined) widthCache.delete(firstKey);
@@ -132,15 +62,21 @@ export function truncateToWidth(value: string, width: number, ellipsis = "…"):
 	if (width <= ellipsis.length) return ellipsis.slice(0, width);
 	let output = "";
 	let renderedWidth = 0;
-	for (let i = 0; i < value.length; i++) {
+	for (let i = 0; i < value.length; ) {
 		const ansiLen = consumeAnsi(value, i);
 		if (ansiLen) {
 			output += value.slice(i, i + ansiLen);
-			i += ansiLen - 1;
+			i += ansiLen;
 			continue;
 		}
-		const char = value[i] as string;
-		const nextIndex = (char.codePointAt(0) ?? 0) > 0xffff ? i + 2 : i + 1;
+		// Read the codepoint at position i on the FULL string — NOT
+		// `value[i].codePointAt(0)`, which for a surrogate pair returns the
+		// lone half (≤ 0xFFFF) and slices each half separately. pi-tui's
+		// visibleWidth zero-widths lone `\p{Surrogate}` halves, so 🤖 would
+		// undercount as 0 and truncation would never cut (latent bug unmasked
+		// once visibleWidth delegated to pi-tui).
+		const codepoint = value.codePointAt(i) ?? 0;
+		const nextIndex = codepoint > 0xffff ? i + 2 : i + 1;
 		const segment = value.slice(i, nextIndex);
 		const charWidth = visibleWidth(segment);
 		if (renderedWidth + charWidth > width - ellipsis.length) {
@@ -148,7 +84,7 @@ export function truncateToWidth(value: string, width: number, ellipsis = "…"):
 		}
 		output += segment;
 		renderedWidth += charWidth;
-		i = nextIndex - 1;
+		i = nextIndex;
 	}
 	return output;
 }

package/src/runtime/auto-resume.ts

@@ -1,100 +0,0 @@
-/**
- * Auto-resume controller with settle window — prevents premature context injection
- * by waiting for Pi's setTimeout(0) + setTimeout(100) to drain before resuming.
- *
- * Distilled from pi-autoresearch's auto-resume / settle-window pattern.
- */
-
-/** Time to wait before auto-resuming (ms). Outlasts Pi's setTimeout(0) + setTimeout(100). */
-export const SETTLE_WINDOW_MS = 800;
-
-/** Maximum number of auto-resume turns before forcing a stop. */
-export const MAX_AUTORESUME_TURNS = 20;
-
-/**
- * Controller for scheduling auto-resume actions with a settle window.
- *
- * The settle window ensures that pending async operations (e.g., Pi's
- * internal setTimeout(0) and setTimeout(100) callbacks) have completed
- * before the resume callback fires.
- */
-export class AutoResumeController {
-	private timerId: ReturnType<typeof setTimeout> | null = null;
-	private turnCount = 0;
-	private cancelled = false;
-
-	/**
-	 * Get the current auto-resume turn count.
-	 */
-	get currentTurnCount(): number {
-		return this.turnCount;
-	}
-
-	/**
-	 * Get the maximum allowed auto-resume turns.
-	 */
-	get maxTurns(): number {
-		return MAX_AUTORESUME_TURNS;
-	}
-
-	/**
-	 * Schedule an auto-resume callback after the settle window elapses.
-	 *
-	 * If a resume is already pending, it is cancelled first (debounce behavior).
-	 * If the turn limit has been reached, the callback is not scheduled.
-	 *
-	 * @param message - Description of why the resume is being scheduled
-	 * @param callback - Function to call after the settle window
-	 */
-	scheduleResume(message: string, callback: () => void): void {
-		// Cancel any existing pending resume
-		this.cancelResume();
-
-		// Enforce turn limit
-		if (this.turnCount >= MAX_AUTORESUME_TURNS) {
-			return;
-		}
-
-		this.cancelled = false;
-		this.turnCount++;
-
-		this.timerId = setTimeout(() => {
-			if (!this.cancelled) {
-				this.timerId = null;
-				callback();
-			}
-		}, SETTLE_WINDOW_MS);
-
-		// Prevent the timer from keeping the process alive
-		if (this.timerId && typeof this.timerId === "object" && "unref" in this.timerId) {
-			this.timerId.unref();
-		}
-	}
-
-	/**
-	 * Cancel any pending auto-resume.
-	 */
-	cancelResume(): void {
-		if (this.timerId !== null) {
-			clearTimeout(this.timerId);
-			this.timerId = null;
-		}
-		this.cancelled = true;
-	}
-
-	/**
-	 * Check whether an auto-resume is currently pending.
-	 */
-	hasPendingResume(): boolean {
-		return this.timerId !== null;
-	}
-
-	/**
-	 * Reset the turn counter. Called when a new agent starts processing
-	 * to allow a fresh set of auto-resume turns.
-	 */
-	resetTurnCount(): void {
-		this.turnCount = 0;
-		this.cancelled = false;
-	}
-}

package/src/runtime/notebook-helpers.ts

@@ -1,88 +0,0 @@
-export interface NotebookCell {
-	index: number;
-	cellType: "code" | "markdown" | "raw";
-	source: string;
-	outputs?: unknown[];
-	metadata?: Record<string, unknown>;
-}
-
-export interface Notebook {
-	cells: NotebookCell[];
-	metadata?: Record<string, unknown>;
-	nbformat: number;
-}
-
-/** Check if a file path is a notebook */
-export function isNotebookPath(filePath: string): boolean {
-	return filePath.toLowerCase().endsWith(".ipynb");
-}
-
-function normalizeSource(source: unknown): string {
-	if (typeof source === "string") return source;
-	if (Array.isArray(source)) return source.join("");
-	return "";
-}
-
-/** Parse a .ipynb JSON file into a Notebook structure */
-export function parseNotebook(content: string): Notebook {
-	let raw: unknown;
-	try {
-		raw = JSON.parse(content);
-	} catch {
-		return { cells: [], nbformat: 4 };
-	}
-	if (typeof raw !== "object" || raw === null) return { cells: [], nbformat: 4 };
-	const obj = raw as Record<string, unknown>;
-	const nbformat = typeof obj.nbformat === "number" ? obj.nbformat : 4;
-	const rawCells = Array.isArray(obj.cells) ? obj.cells : [];
-	const cells: NotebookCell[] = rawCells
-		.map((c: unknown, i: number): NotebookCell | null => {
-			if (typeof c !== "object" || c === null) return null;
-			const cell = c as Record<string, unknown>;
-			const cellType = cell.cell_type;
-			if (cellType !== "code" && cellType !== "markdown" && cellType !== "raw") return null;
-			return {
-				index: i,
-				cellType,
-				source: normalizeSource(cell.source),
-				outputs: Array.isArray(cell.outputs) ? cell.outputs : undefined,
-				metadata:
-					cell.metadata && typeof cell.metadata === "object" && !Array.isArray(cell.metadata)
-						? (cell.metadata as Record<string, unknown>)
-						: undefined,
-			};
-		})
-		.filter((c: NotebookCell | null): c is NotebookCell => c !== null);
-	const metadata =
-		obj.metadata && typeof obj.metadata === "object" && !Array.isArray(obj.metadata)
-			? (obj.metadata as Record<string, unknown>)
-			: undefined;
-	return { cells, metadata, nbformat };
-}
-
-/** Get a specific cell by index */
-export function getCell(notebook: Notebook, index: number): NotebookCell | undefined {
-	return notebook.cells.find((c) => c.index === index);
-}
-
-/** Update a cell's source content, returning a new Notebook */
-export function updateCell(notebook: Notebook, index: number, source: string): Notebook {
-	const cells = notebook.cells.map((c) => (c.index === index ? { ...c, source } : c));
-	return { ...notebook, cells };
-}
-
-/** Serialize a Notebook back to .ipynb JSON string */
-export function serializeNotebook(notebook: Notebook): string {
-	const raw = {
-		nbformat: notebook.nbformat,
-		nbformat_minor: 5,
-		metadata: notebook.metadata ?? {},
-		cells: notebook.cells.map((c) => ({
-			cell_type: c.cellType,
-			source: c.source,
-			metadata: c.metadata ?? {},
-			...(c.cellType === "code" ? { outputs: c.outputs ?? [], execution_count: null } : {}),
-		})),
-	};
-	return JSON.stringify(raw, null, 2) + "\n";
-}

package/src/runtime/orphan-sentinel.ts

@@ -1,7 +0,0 @@
-/**
- * Orphan sentinel — DEPRECATED, replaced by parent-guard.ts.
- *
- * Keeping this file as a no-op placeholder until all references are removed.
- * Workers now self-monitor via startParentGuard() instead of relying on
- * an external sentinel process.
- */