pi-crew 0.9.42 → 0.9.46

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/paths.ts

@@ -44,7 +44,7 @@ export function userPiRoot(): string {
 	// "undefined/.pi/agent" relative to cwd and silently create a junk "undefined/"
 	// tree. Treat the literal "undefined" (and empty) as unset and fall back to
 	// os.homedir().
-	const rawHome = process.env.PI_TEAMS_HOME?.trim();
+	const rawHome = (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim();
 	const home = rawHome && rawHome !== "undefined" ? rawHome : os.homedir();
 	const resolved = path.join(home, ".pi", "agent");
 

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/worktree/worktree-manager.ts

@@ -134,7 +134,11 @@ export function findGitRoot(cwd: string): string {
 }
 
 export function assertCleanLeader(repoRoot: string): void {
-	const status = git(repoRoot, ["status", "--porcelain"]);
+	// H-7 follow-up: --untracked-files=no so pi-crew's own auto-created .gitignore
+	// (and any other untracked files the user hasn't staged) doesn't block worktree mode.
+	// The worktree contract is "no tracked changes" — untracked files are safe since
+	// they're either in .gitignore or the user can decide later.
+	const status = git(repoRoot, ["status", "--porcelain", "--untracked-files=no"]);
 	if (status.trim()) {
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
@@ -168,7 +172,9 @@ export function clearCleanLeaderCache(): void {
 
 export async function assertCleanLeaderAsync(repoRoot: string): Promise<void> {
 	if (_cleanLeaderCache.has(repoRoot)) return;
-	const status = await gitAsync(repoRoot, ["status", "--porcelain"]);
+	// H-7 follow-up: --untracked-files=no so pi-crew's own auto-created .gitignore
+	// (and any other untracked files the user hasn't staged) doesn't block worktree mode.
+	const status = await gitAsync(repoRoot, ["status", "--porcelain", "--untracked-files=no"]);
 	if (status.trim()) {
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
@@ -558,7 +564,7 @@ export function overlaySeedPaths(repoRoot: string, worktreePath: string, seedPat
  * recovered via `git apply` / manual restore. Best-effort: a snapshot failure
  * only logs (it must not block the clean-slate reuse flow).
  */
-function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): void {
+function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
 	try {
 		const parts: string[] = [
 			`# Worktree recovery snapshot`,
@@ -596,12 +602,14 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			producer: "worktree-manager.snapshotDirtyWorktree",
 			retention: "run",
 		});
+		return true;
 	} catch (err) {
 		logInternalError(
 			"worktree.recovery.snapshotFailed",
 			err instanceof Error ? err : new Error(String(err)),
 			`runId=${manifest.runId}, taskId=${task.id}`,
 		);
+		return false;
 	}
 }
 
@@ -722,14 +730,24 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		if (dirtyStatus.trim()) {
 			// Snapshot uncommitted work to a recovery artifact BEFORE discarding, so the
 			// previous run's changes are never silently destroyed on reuse.
-			snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
-			logInternalError(
-				"worktree.reused.dirty",
-				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
-				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
-			);
-			git(worktreePath, ["checkout", "--", "."]);
-			git(worktreePath, ["clean", "-fd"]);
+			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
+			if (snapshotOk) {
+				logInternalError(
+					"worktree.reused.dirty",
+					new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+				git(worktreePath, ["checkout", "--", "."]);
+				git(worktreePath, ["clean", "-fd"]);
+			} else {
+				logInternalError(
+					"worktree.reused.dirtyPreserved",
+					new Error(
+						`Snapshot failed — preserving dirty worktree at ${worktreePath} (skipping git checkout/clean to prevent data loss)`,
+					),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+			}
 		}
 		// Overlay seed paths from config + step-level seedPaths (reused worktree)
 		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
@@ -869,14 +887,24 @@ export async function prepareTaskWorkspaceAsync(
 		}
 		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain"]);
 		if (dirtyStatus.trim()) {
-			snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
-			logInternalError(
-				"worktree.reused.dirty",
-				new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
-				`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
-			);
-			await gitAsync(worktreePath, ["checkout", "--", "."]);
-			await gitAsync(worktreePath, ["clean", "-fd"]);
+			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
+			if (snapshotOk) {
+				logInternalError(
+					"worktree.reused.dirty",
+					new Error(`Discarding uncommitted changes in reused worktree at ${worktreePath} (snapshot saved to artifacts)`),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+				await gitAsync(worktreePath, ["checkout", "--", "."]);
+				await gitAsync(worktreePath, ["clean", "-fd"]);
+			} else {
+				logInternalError(
+					"worktree.reused.dirtyPreserved",
+					new Error(
+						`Snapshot failed — preserving dirty worktree at ${worktreePath} (skipping git checkout/clean to prevent data loss)`,
+					),
+					`runId=${manifest.runId}, taskId=${task.id}, dirtyStatus=${dirtyStatus.trim()}`,
+				);
+			}
 		}
 		const globalSeedPaths = loadedConfig.config.worktree?.seedPaths ?? [];
 		const mergedReused = normalizeSeedPaths([...globalSeedPaths, ...(stepSeedPaths ?? [])], repoRoot);

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.
- */