pi-crew 0.5.13 → 0.5.16

package/src/runtime/child-pi.ts

@@ -8,7 +8,7 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "./post-exit-stdio-guard.ts";
-import { redactJsonLine, isSecretKey } from "../utils/redaction.ts";
+import { redactJsonLine } from "../utils/redaction.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { registerChildProcess, unregisterChildProcess } from "../extension/crew-cleanup.ts";
 

package/src/runtime/crash-recovery.ts

@@ -11,7 +11,7 @@ import type { ManifestCache } from "./manifest-cache.ts";
 import { checkProcessLiveness } from "./process-status.ts";
 import { reconcileStaleRun, type ReconcileResult } from "./stale-reconciler.ts";
 import { executeHook, appendHookEvent } from "../hooks/registry.ts";
-import { activeRunEntries, unregisterActiveRun, readActiveRunRegistry } from "../state/active-run-registry.ts";
+import { unregisterActiveRun, readActiveRunRegistry } from "../state/active-run-registry.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { terminateLiveAgentsForRun } from "./live-agent-manager.ts";

package/src/runtime/crew-agent-records.ts

@@ -263,8 +263,28 @@ export function readCrewAgentStatus(manifest: TeamRunManifest, taskOrAgentId: st
 }
 
 const agentEventSeqCache = new Map<string, { size: number; mtimeMs: number; seq: number }>();
+// FIX (Round 22, defensive cap): Bound the per-file-path cache. Without a cap,
+// a long-running pi-crew process that spawns 1000s of agents accumulates 1000s
+// of entries. Mirrors the `asyncAgentReaderCache` pattern (above) and the
+// `NotificationRouter.SEEN_MAP_MAX_SIZE` pattern.
+const AGENT_EVENT_SEQ_CACHE_MAX_ENTRIES = 1000;
 const AGENT_EVENT_SEQ_SIDECAR = ".seq";
 
+/**
+ * Set an entry in the seq cache, evicting the oldest entries when the cache
+ * exceeds the cap. Map's natural insertion order means the first key is the
+ * oldest — same as the pattern used in `asyncAgentReaderCache`.
+ */
+function setAgentEventSeqCache(filePath: string, entry: { size: number; mtimeMs: number; seq: number }): void {
+	if (agentEventSeqCache.has(filePath)) agentEventSeqCache.delete(filePath);
+	agentEventSeqCache.set(filePath, entry);
+	while (agentEventSeqCache.size > AGENT_EVENT_SEQ_CACHE_MAX_ENTRIES) {
+		const oldest = agentEventSeqCache.keys().next().value;
+		if (oldest === undefined) break;
+		agentEventSeqCache.delete(oldest);
+	}
+}
+
 function readSeqFromSidecar(filePath: string): number | undefined {
 	try {
 		const raw = fs.readFileSync(`${filePath}.${AGENT_EVENT_SEQ_SIDECAR}`, "utf-8");
@@ -295,7 +315,7 @@ function nextAgentEventSeq(filePath: string): number {
 	// FIX: Try sidecar file for O(1) lookup before falling back to O(n) scan.
 	const sidecarSeq = readSeqFromSidecar(filePath);
 	if (sidecarSeq !== undefined) {
-		agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: sidecarSeq });
+		setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: sidecarSeq });
 		return sidecarSeq + 1;
 	}
 	let max = 0;
@@ -309,7 +329,7 @@ function nextAgentEventSeq(filePath: string): number {
 			max += 1;
 		}
 	}
-	agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: max });
+	setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: max });
 	writeSeqToSidecar(filePath, max);
 	return max + 1;
 }
@@ -321,7 +341,7 @@ export function appendCrewAgentEvent(manifest: TeamRunManifest, taskId: string,
 	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ seq, time: new Date().toISOString(), event }))}\n`, "utf-8");
 	try {
 		const stat = fs.statSync(filePath);
-		agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
+		setAgentEventSeqCache(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
 		writeSeqToSidecar(filePath, seq);
 	} catch (error) {
 		logInternalError("crew-agent-records.stat", error, `filePath=${filePath}`);

package/src/runtime/crew-hooks.ts

@@ -146,7 +146,7 @@ export class HookRegistry {
 	emit(event: CrewHookEvent): void {
 		// Validate event type using type guard
 		if (!isValidEventType(event.type)) {
-			console.warn(`[crew-hooks] Unknown event type: ${event.type}`);
+			logInternalError("crew-hooks.unknown-event-type", new Error(`Unknown event type: ${event.type}`));
 			return;
 		}
 

package/src/runtime/handoff-manager.ts

@@ -55,7 +55,6 @@ export function isValidHandoffSummary(value: unknown): value is HandoffSummary {
  */
 
 import type { TeamEvent } from "../state/event-log.ts";
-import { appendEventAsync } from "../state/event-log.ts";
 
 /**
  * Represents a key decision made during task execution.

package/src/runtime/heartbeat-watcher.ts

@@ -6,7 +6,7 @@ import { loadRunManifestById } from "../state/state-store.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { ManifestCache } from "./manifest-cache.ts";
-import { classifyHeartbeat, DEFAULT_GRADIENT_THRESHOLDS, heartbeatAgeMs, type GradientThresholds, type HeartbeatLevel } from "./heartbeat-gradient.ts";
+import { DEFAULT_GRADIENT_THRESHOLDS, heartbeatAgeMs, type GradientThresholds, type HeartbeatLevel } from "./heartbeat-gradient.ts";
 
 export interface HeartbeatWatcherRouter {
 	enqueue(notification: NotificationDescriptor): boolean;

package/src/runtime/live-session-runtime.ts

@@ -24,7 +24,6 @@ import { buildExtensionBridge } from "./live-extension-bridge.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 // prose-compressor imported for custom tool descriptions below;
 // tool description compression for SDK-managed tools awaits SDK support.
-import { compressToolDescription } from "./prose-compressor.ts";
 import { buildSensitivePathConstraint } from "./sensitive-paths.ts";
 import { collectLiveSessionHealth, formatLiveSessionDiagnostics, type LiveSessionHealth } from "./live-session-health.ts";
 import { listLiveAgents } from "./live-agent-manager.ts";

package/src/runtime/loop-gates.ts

@@ -8,7 +8,6 @@
  * Distilled from pi-autoresearch's dual-gate loop pattern.
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
 import type { TeamTaskState } from "../state/types.ts";
 
 /**

package/src/runtime/mcp-proxy.ts

@@ -16,8 +16,8 @@
  * when proxying from the parent.
  */
 
-import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type, type Static, type TSchema } from "@sinclair/typebox";
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, type TSchema } from "@sinclair/typebox";
 
 export interface McpProxyConfig {
 	/** Whether to enable MCP in the child session. */

package/src/runtime/pipeline-runner.ts

@@ -2,8 +2,7 @@ import type { TeamTaskState } from "../state/types.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { AgentConfig } from "../agents/agent-config.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent, appendEventAsync } from "../state/event-log.ts";
+import { appendEventAsync } from "../state/event-log.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 
 /**

package/src/runtime/task-runner/live-executor.ts

@@ -3,7 +3,6 @@ import type { AgentConfig } from "../../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../../config/config.ts";
 import { writeArtifact } from "../../state/artifact-store.ts";
 import {
-	appendEvent,
 	appendEventFireAndForget,
 } from "../../state/event-log.ts";
 import type {
@@ -11,7 +10,7 @@ import type {
 	TeamRunManifest,
 	TeamTaskState,
 } from "../../state/types.ts";
-import { loadRunManifestById, saveRunTasks } from "../../state/state-store.ts";
+import { loadRunManifestById } from "../../state/state-store.ts";
 import { persistSingleTaskUpdate } from "./state-helpers.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "../crew-agent-records.ts";

package/src/runtime/task-runner.ts

@@ -11,7 +11,7 @@ import type {
 } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent, appendEventAsync, appendEventFireAndForget } from "../state/event-log.ts";
+import { appendEventAsync, appendEventFireAndForget } from "../state/event-log.ts";
 import { saveRunManifest } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import {

package/src/state/jsonl-writer.ts

@@ -14,10 +14,17 @@ export interface JsonlWriteStream {
 }
 
 const DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
+// FIX (Round 21, per-line cap): A single huge line could exhaust memory during
+// redactJsonLine if an upstream caller constructs an enormous string. Cap each
+// line at 1MB by default — large enough for any legitimate event payload, small
+// enough to prevent memory blow-up. Mirrors the upstream oh-my-pi pattern of
+// bounding chunk boundaries in Bun.file().writer().
+const DEFAULT_MAX_LINE_BYTES = 1 * 1024 * 1024;
 
 export interface JsonlWriterDeps {
 	createWriteStream?: (filePath: string) => JsonlWriteStream;
 	maxBytes?: number;
+	maxLineBytes?: number;
 }
 
 export interface JsonlWriter {
@@ -47,7 +54,9 @@ export function createJsonlWriter(filePath: string | undefined, source: Drainabl
 	let backpressured = false;
 	let closed = false;
 	let bytesWritten = 0;
+	let linesDroppedForSize = 0;
 	const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
+	const maxLineBytes = deps.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
 
 	return {
 		writeLine(line: string) {
@@ -55,6 +64,21 @@ export function createJsonlWriter(filePath: string | undefined, source: Drainabl
 			const safeLine = redactJsonLine(line);
 			const chunk = `${safeLine}\n`;
 			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+			// FIX (Round 21, per-line cap): Drop oversize lines. Without this, a
+			// single huge payload (e.g. a 100MB base64-encoded transcript) would
+			// be buffered in memory by redactJsonLine AND queued in the write
+			// stream. We log the drop so silent loss is visible.
+			if (chunkBytes > maxLineBytes) {
+				linesDroppedForSize++;
+				if (linesDroppedForSize === 1 || linesDroppedForSize % 100 === 0) {
+					logInternalError(
+						"jsonl-writer.lineTooLarge",
+						new Error(`line size ${chunkBytes} exceeds maxLineBytes ${maxLineBytes}`),
+						`file=${filePath} dropped=${linesDroppedForSize}`,
+					);
+				}
+				return;
+			}
 			if (bytesWritten + chunkBytes > maxBytes) return;
 			try {
 				const ok = stream.write(chunk);

package/src/state/locks.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { randomUUID } from "node:crypto";
 import type { TeamRunManifest } from "./types.ts";
 import { DEFAULT_LOCKS } from "../config/defaults.ts";
 import { sleepSync } from "../utils/sleep.ts";
@@ -59,22 +60,71 @@ function isLockHolderAlive(filePath: string): boolean {
 	}
 }
 
-function writeLockFile(filePath: string): void {
+/**
+ * Lock file kinds. Discriminator written to the lock file payload so that:
+ *   - Debugging tools (e.g. a future `pi-crew locks` command) can identify
+ *     what a lock is protecting.
+ *   - Cross-kind ambiguity is prevented if two locks somehow resolve to the
+ *     same path (defense in depth).
+ *   - Forward compat: new lock types can be added without changing the
+ *     on-disk format (the `kind` field is the only discriminator).
+ */
+export type LockKind = "run" | "file";
+
+function writeLockFile(filePath: string, token: string, kind: LockKind = "file"): void {
 	const fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
 	try {
-		fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+		fs.writeSync(fd, JSON.stringify({ kind, pid: process.pid, createdAt: new Date().toISOString(), token }));
 	} finally {
 		fs.closeSync(fd);
 	}
 }
 
-function acquireLockWithRetry(filePath: string, staleMs: number): void {
+/**
+ * Read the token stored in a lock file. Returns undefined if the file
+ * cannot be read or parsed.
+ */
+function readLockToken(filePath: string): string | undefined {
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw) as { token?: unknown };
+		return typeof parsed.token === "string" ? parsed.token : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Release a lock file, but ONLY if the stored token matches. This prevents
+ * the "losing contender wipes winner's lock" race that occurs when:
+ *   1. Process A acquires lock with token T_A
+ *   2. Process B times out waiting, steals the lock (overwriting with T_B)
+ *   3. Process A finishes, tries to release — would otherwise rm Process B's lock
+ *
+ * With token matching, A's release is a no-op for B's lock.
+ */
+function releaseLock(filePath: string, token: string): void {
+	const stored = readLockToken(filePath);
+	if (stored === undefined || stored === token) {
+		try {
+			fs.rmSync(filePath, { force: true });
+		} catch {
+			// Best-effort cleanup. Either someone else with the same token got
+			// there first, or the lock is already gone — both are fine.
+		}
+	}
+	// If the stored token does not match, our lock has been stolen
+	// (probably stale and overtaken). Do not touch it — the new holder owns it.
+}
+
+function acquireLockWithRetry(filePath: string, staleMs: number, kind: LockKind = "file"): string {
 	let attempt = 0;
 	const deadline = Date.now() + staleMs * 2;
 	while (true) {
+		const token = randomUUID();
 		try {
-			writeLockFile(filePath);
-			return;
+			writeLockFile(filePath, token, kind);
+			return token;
 		} catch (error) {
 			const code = (error as NodeJS.ErrnoException).code;
 			if (code !== "EEXIST") throw error;
@@ -105,21 +155,14 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function readLockStateAsync(filePath: string, staleMs: number): void {
-	try {
-		if (isLockStale(filePath, staleMs)) fs.rmSync(filePath, { force: true });
-	} catch {
-		// Ignore stale-check races.
-	}
-}
-
-async function acquireLockWithRetryAsync(filePath: string, staleMs: number): Promise<void> {
+async function acquireLockWithRetryAsync(filePath: string, staleMs: number, kind: LockKind = "file"): Promise<string> {
 	let attempt = 0;
 	const deadline = Date.now() + staleMs * 2;
 	while (true) {
+		const token = randomUUID();
 		try {
-			writeLockFile(filePath);
-			return;
+			writeLockFile(filePath, token, kind);
+			return token;
 		} catch (error) {
 			const code = (error as NodeJS.ErrnoException).code;
 			if (code !== "EEXIST") throw error;
@@ -139,7 +182,6 @@ async function acquireLockWithRetryAsync(filePath: string, staleMs: number): Pro
 			try {
 				fs.rmSync(filePath, { force: true });
 			} catch { /* race — let loop retry */ }
-			await readLockStateAsync(filePath, staleMs);
 			const delay = Math.min(250, 25 * 2 ** attempt);
 			await sleep(delay);
 			attempt++;
@@ -159,15 +201,12 @@ export function withFileLockSync<T>(filePath: string, fn: () => T, options: RunL
 	const lockFile = `${filePath}.lock`;
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
 	fs.mkdirSync(path.dirname(lockFile), { recursive: true });
-	acquireLockWithRetry(lockFile, staleMs);
+	const token = acquireLockWithRetry(lockFile, staleMs, "file");
 	try {
 		return fn();
 	} finally {
-		try {
-			fs.rmSync(lockFile, { force: true });
-		} catch {
-			// Best-effort lock cleanup.
-		}
+		// Token-guarded release: don't rm the lock if it has been stolen.
+		releaseLock(lockFile, token);
 	}
 }
 
@@ -175,15 +214,11 @@ export function withRunLockSync<T>(manifest: TeamRunManifest, fn: () => T, optio
 	const filePath = lockPath(manifest);
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	acquireLockWithRetry(filePath, staleMs);
+	const token = acquireLockWithRetry(filePath, staleMs, "run");
 	try {
 		return fn();
 	} finally {
-		try {
-			fs.rmSync(filePath, { force: true });
-		} catch {
-			// Best-effort lock cleanup.
-		}
+		releaseLock(filePath, token);
 	}
 }
 
@@ -191,14 +226,10 @@ export async function withRunLock<T>(manifest: TeamRunManifest, fn: () => Promis
 	const filePath = lockPath(manifest);
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	await acquireLockWithRetryAsync(filePath, staleMs);
+	const token = await acquireLockWithRetryAsync(filePath, staleMs, "run");
 	try {
 		return await fn();
 	} finally {
-		try {
-			fs.rmSync(filePath, { force: true });
-		} catch {
-			// Best-effort lock cleanup.
-		}
+		releaseLock(filePath, token);
 	}
 }

package/src/state/run-metrics.ts

@@ -1,9 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadRunManifestById } from "./state-store.ts";
-import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
 import { atomicWriteJson, readJsonFile } from "./atomic-write.ts";
-import { DEFAULT_PATHS } from "../config/defaults.ts";
 
 /**
  * Run metrics snapshot captured after a run completes (or on demand).

package/src/state/schedule.ts

@@ -7,6 +7,9 @@
  *   - parseRelativeTime(): "+10m" → ISO timestamp
  *   - parseInterval(): "5m" → milliseconds
  */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logInternalError } from "../utils/internal-error.ts";
 
 import type { ScheduleStoreData, ScheduledTask } from "./types.ts";
 
@@ -88,8 +91,8 @@ export class ScheduleStore {
 		this.path = path;
 		this.data = { version: 1, jobs: [] };
 		try {
-			if (require("node:fs").existsSync(path)) {
-				const content = require("node:fs").readFileSync(path, "utf-8");
+			if (fs.existsSync(path)) {
+				const content = fs.readFileSync(path, "utf-8");
 				const parsed = JSON.parse(content);
 				if (parsed && typeof parsed === "object" && "version" in parsed && "jobs" in parsed) {
 					this.data = parsed as ScheduleStoreData;
@@ -102,10 +105,15 @@ export class ScheduleStore {
 
 	private save(): void {
 		try {
-			require("node:fs").mkdirSync(require("node:path").dirname(this.path), { recursive: true });
-			require("node:fs").writeFileSync(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+			fs.mkdirSync(path.dirname(this.path), { recursive: true });
+			fs.writeFileSync(this.path, JSON.stringify(this.data, null, 2), "utf-8");
 		} catch (error) {
-			console.warn(`[pi-crew] Failed to save schedule store: ${error instanceof Error ? error.message : String(error)}`);
+			// FIX (Round 21, L1): Use logInternalError for consistency with
+			// the rest of the codebase. Previously console.warn may not be
+			// visible in all environments (e.g. JSON-RPC mode, redirected
+			// stderr). Also import the dependency properly at the top of
+			// the file (this method used the legacy require() pattern).
+			logInternalError("schedule.save", error, `path=${this.path}`);
 		}
 	}
 

package/src/state/state-store.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamRunManifest, TeamTaskState } from "./types.ts";
-import { canTransitionRunStatus, isTerminalRunStatus } from "./contracts.ts";
+import { canTransitionRunStatus } from "./contracts.ts";
 import { unregisterActiveRun } from "./active-run-registry.ts";
 import { atomicWriteJson, atomicWriteJsonAsync, atomicWriteJsonCoalesced, readJsonFile } from "./atomic-write.ts";
 import { appendEvent } from "./event-log.ts";

package/src/tools/safe-bash.ts

@@ -4,7 +4,6 @@
  * Uses linear-time scanning to prevent ReDoS attacks
  */
 
-import { Type } from "@sinclair/typebox";
 
 // Backward-compatible pattern array (kept for getPatterns API)
 // IMPORTANT: Line 8 (rm pattern with nested quantifiers) has been replaced

package/src/ui/crew-widget.ts

@@ -9,8 +9,8 @@ import { getTaskUsage } from "../runtime/usage-tracker.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import { reconcileAllStaleRuns } from "../runtime/crash-recovery.ts";
-import { colorForStatus, iconForStatus, type RunStatus } from "./status-colors.ts";
-import { pad, truncate } from "../utils/visual.ts";
+import { iconForStatus } from "./status-colors.ts";
+import { truncate } from "../utils/visual.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "./theme-adapter.ts";
 import { Box, Text } from "./layout-primitives.ts";

package/src/ui/render-diff.ts

@@ -18,7 +18,7 @@ function parseDiffLine(line: string): ParsedDiffLine | null {
 	return { prefix: match[1], lineNum: match[2], content: match[3] };
 }
 
-function replaceTabs(text: string): string {
+export function replaceTabs(text: string): string {
 	return text.replace(/\t/g, "   ");
 }
 

package/src/ui/run-dashboard.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
-import { getLiveAgentContextPercent, listLiveAgents } from "../runtime/live-agent-manager.ts";
+import { getLiveAgentContextPercent } from "../runtime/live-agent-manager.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
 import { readJsonFileCoalesced } from "../utils/file-coalescer.ts";
@@ -11,7 +11,6 @@ import { applyStatusColor, iconForStatus, type RunStatus } from "./status-colors
 import { pad, truncate, sanitizeLine } from "../utils/visual.ts";
 import { Box, Text } from "./layout-primitives.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
-import { CrewFooter } from "./crew-footer.ts";
 import { aggregateUsage } from "../state/usage.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { renderAgentsPane } from "./dashboard-panes/agents-pane.ts";

package/src/ui/tool-render.ts

@@ -5,6 +5,7 @@
  */
 import { Container, Spacer, Text, visibleWidth } from "@earendil-works/pi-tui";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
+import { replaceTabs } from "./render-diff.ts";
 
 // ── Types ──────────────────────────────────────────────────────────────
 export interface Theme {
@@ -185,7 +186,15 @@ export function renderAgentProgress(
 	}
 
 	// Error
-	if (record.error) addLine(theme.fg("error", `Error: ${record.error}`));
+	// FIX (Round 20, render-utils sanitization): Sanitize tool-error display so
+	// embedded tabs / control chars / newlines / very long strings cannot break
+	// the terminal layout. Mirrors the upstream oh-my-pi pattern at
+	// packages/coding-agent/src/tools/render-utils.ts:177-185:
+	//   formatErrorMessage = replaceTabs(truncateToWidth(clean, LINE_CAP))
+	if (record.error) {
+		const clean = truncLine(replaceTabs(String(record.error)), innerW);
+		addLine(theme.fg("error", `Error: ${clean}`));
+	}
 
 	// Usage line
 	const usage = record.usage;
@@ -300,7 +309,12 @@ export function renderAgentToolResult(
 			const label = item.agentId || "agent";
 			c.addChild(new Text(`${icon}  ${theme.fg("toolTitle", theme.bold(label))}`, 0, 0));
 			if (item.error) {
-				c.addChild(new Text(theme.fg("error", `  Error:  ${item.error}`), 0, 0));
+				// FIX (Round 20, render-utils sanitization): Sanitize tool-error
+				// display so embedded tabs / newlines / very long strings cannot
+				// break the TUI border alignment. Mirrors upstream oh-my-pi
+				// render-utils.ts:177-185.
+				const clean = truncLine(replaceTabs(String(item.error)), w - 2);
+				c.addChild(new Text(theme.fg("error", `  Error:  ${clean}`), 0, 0));
 			} else if (item.output) {
 				for (const line of item.output.split("\n").slice(0, 5))
 					c.addChild(new Text(theme.fg("dim", `  ${truncLine(line, w - 2)}`), 0, 0));
@@ -318,7 +332,10 @@ export function renderAgentToolResult(
 		const label = d.agentId;
 		c.addChild(new Text(`${icon}  ${theme.fg("toolTitle", theme.bold(label))}`, 0, 0));
 		if (d.error) {
-			c.addChild(new Text(theme.fg("error", `  Error:  ${d.error}`), 0, 0));
+			// FIX (Round 20, render-utils sanitization): Same sanitization as
+			// above — see renderAgentToolResult header comment.
+			const clean = truncLine(replaceTabs(String(d.error)), w - 2);
+			c.addChild(new Text(theme.fg("error", `  Error:  ${clean}`), 0, 0));
 		} else if (d.output) {
 			for (const line of d.output.split("\n").slice(0, 5))
 				c.addChild(new Text(theme.fg("dim", `  ${truncLine(line, w - 2)}`), 0, 0));

package/src/utils/conflict-detect.ts

@@ -20,7 +20,6 @@
  * merely start with `<` or `=` never match.
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
 
 const OURS_PREFIX = "<<<<<<<";
 const BASE_PREFIX = "|||||||";

package/src/utils/gh-protocol.ts

@@ -22,8 +22,6 @@
  * Repo resolution: git remote get-url origin from cwd.
  */
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import * as path from "node:path";
 
 /** Resolve the default repo from `git remote get-url origin` in cwd. */
 export function resolveDefaultRepo(cwd: string): string {