pi-crew 0.5.14 → 0.5.17

package/src/runtime/task-packet.ts

@@ -128,6 +128,130 @@ export function validateTaskPacket(packet: TaskPacket): TaskPacketValidationResu
 	return { valid: errors.length === 0, errors };
 }
 
+/**
+ * Structured handoff template for task completion reports.
+ * Distilled from ECC dmux-workflows pattern — workers use this format
+ * so verifiers and downstream consumers can parse output predictably.
+ */
+export const HANDOFF_TEMPLATE = [
+	"## Handoff",
+	"",
+	"### Summary",
+	"<!-- 2-3 sentences describing what was done -->",
+	"",
+	"### Files Changed",
+	"<!-- List each file changed with brief description -->",
+	"<!-- - path/to/file.ts: description -->",
+	"",
+	"### Tests / Verification",
+	"<!-- What tests pass? What was manually verified? -->",
+	"",
+	"### Follow-ups",
+	"<!-- Any remaining issues or next steps -->",
+].join("\n");
+
+export interface ParsedHandoff {
+	summary: string[];
+	filesChanged: string[];
+	tests: string[];
+	followups: string[];
+}
+
+/**
+ * Extract text between a ### heading and the next ### heading or end of text.
+ */
+function extractSection(content: string, heading: string): string {
+	const lines = content.split("\n");
+	const headingMarker = `### ${heading}`;
+	const startIndex = lines.findIndex((line) => line.trim() === headingMarker);
+	if (startIndex === -1) return "";
+
+	const collected: string[] = [];
+	for (let i = startIndex + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed.startsWith("### ") || trimmed.startsWith("## ")) break;
+		// Stop at paragraph text (non-bullet, non-comment, non-empty) that follows
+		// a blank line — signals end of subsection content.
+		if (
+			trimmed.length > 0 &&
+			!trimmed.startsWith("- ") &&
+			!trimmed.startsWith("<!--") &&
+			i > startIndex + 1 &&
+			lines[i - 1].trim() === "" &&
+			collected.some((l) => l.trim().length > 0)
+		) {
+			break;
+		}
+		collected.push(lines[i]);
+	}
+
+	return collected.join("\n").trim();
+}
+
+/**
+ * Parse bullet list items from a section, stripping leading "- " and backtick wrapping.
+ */
+function parseBullets(section: string): string[] {
+	if (!section) return [];
+	return section
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.startsWith("- "))
+		.map((line) => {
+			let item = line.replace(/^- /, "").trim();
+			// Strip surrounding backticks
+			if (item.startsWith("`") && item.endsWith("`") && item.length >= 2) {
+				item = item.slice(1, -1);
+			}
+			return item;
+		});
+}
+
+/**
+ * Parse a handoff section that may contain bullets AND free-text paragraphs.
+ * Returns all non-empty lines as individual items (bullets get their marker stripped).
+ */
+function parseMixedContent(section: string): string[] {
+	if (!section) return [];
+	return section
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0 && !line.startsWith("<!--")) // skip HTML comments
+		.map((line) => {
+			if (line.startsWith("- ")) return line.slice(2).trim();
+			return line;
+		})
+		.map((item) => {
+			// Strip surrounding backticks
+			if (item.startsWith("`") && item.endsWith("`") && item.length >= 2) {
+				return item.slice(1, -1);
+			}
+			return item;
+		});
+}
+
+/**
+ * Parse structured handoff data from agent output text.
+ * Looks for the "## Handoff" heading and extracts subsections.
+ * Returns empty arrays for sections not found.
+ */
+export function parseHandoffFromOutput(output: string): ParsedHandoff {
+	if (!output || typeof output !== "string") {
+		return { summary: [], filesChanged: [], tests: [], followups: [] };
+	}
+
+	// Find the handoff section — look for ## Handoff
+	const handoffIndex = output.indexOf("## Handoff");
+	const content = handoffIndex >= 0 ? output.slice(handoffIndex) : output;
+
+	return {
+		summary: parseMixedContent(extractSection(content, "Summary")),
+		filesChanged: parseMixedContent(extractSection(content, "Files Changed")),
+		tests: parseMixedContent(extractSection(content, "Tests / Verification")),
+		followups: parseMixedContent(extractSection(content, "Follow-ups")),
+	};
+}
+
 export function renderTaskPacket(packet: TaskPacket): string {
 	return [
 		"# Task Packet",

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/prompt-builder.ts

@@ -3,7 +3,7 @@ import type { TeamRunManifest, TeamTaskState, TaskOutputSchema } from "../../sta
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import { buildMemoryBlock } from "../agent-memory.ts";
 import { permissionForRole } from "../role-permission.ts";
-import { renderTaskPacket } from "../task-packet.ts";
+import { renderTaskPacket, HANDOFF_TEMPLATE } from "../task-packet.ts";
 import { buildWorkspaceTree } from "../workspace-tree.ts";
 
 /**
@@ -132,6 +132,9 @@ export async function renderTaskPrompt(manifest: TeamRunManifest, step: Workflow
 		task.taskPacket?.outputSchema ? renderOutputSchemaBlock(task.taskPacket.outputSchema) : "",
 		"Task:",
 		step.task.replaceAll("{goal}", manifest.goal),
+		"",
+		"When your task is complete, structure your final output using this handoff template:",
+		HANDOFF_TEMPLATE,
 	].join("\n");
 
 	const full = [stablePrefix, "", dynamicSuffix].join("\n");

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 {
@@ -156,7 +156,7 @@ export async function runTeamTask(
 	let streamBridge: ReturnType<typeof registerStreamBridge> | undefined;
 	try {
 		streamBridge = registerStreamBridge(manifest.runId);
-		const workspace = prepareTaskWorkspace(manifest, input.task);
+		const workspace = prepareTaskWorkspace(manifest, input.task, input.step.seedPaths);
 		const worktree =
 			workspace.worktreePath && workspace.branch
 				? {

package/src/schema/config-schema.ts

@@ -56,6 +56,7 @@ export const PiTeamsWorktreeConfigSchema = Type.Object({
 	setupHook: Type.Optional(Type.String({ minLength: 1 })),
 	setupHookTimeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
 	linkNodeModules: Type.Optional(Type.Boolean()),
+	seedPaths: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
 }, { additionalProperties: false });
 
 export const AgentOverrideSchema = Type.Object({

package/src/state/event-log.ts

@@ -66,6 +66,13 @@ let appendCounter = 0;
  *
  *  @deprecated Prefer `appendEventAsync()` for callers in async contexts. The sync lock
  *  uses `sleepSync` which blocks the event loop and prevents AbortSignal handlers from firing.
+ *
+ *  SECURITY WARNING: This function uses `sleepSync` in its lock-acquire retry loop, which
+ *  blocks the Node.js event loop for up to 120s. During that time, AbortSignal handlers
+ *  cannot fire, SIGTERM handlers are delayed, and the process appears unresponsive to
+ *  orchestrator health checks. Known callers include `appendEvent` (sync path),
+ *  `flushOneEventLogBuffer`, and `state/mailbox.ts`. Prefer the async alternative
+ *  (`appendEventAsync`) for all new code.
  */
 export function withEventLogLockSync<T>(eventsPath: string, fn: () => T): T {
 	// Ensure parent directory exists before attempting lock

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-extension.ts

@@ -84,7 +84,7 @@ export default function safeBashExtension(pi: ExtensionAPI): void {
 					content: [
 						{
 							type: "text" as const,
-							text: `🚫 ${danger}\n\nIf you need to run this command, use the regular 'bash' tool instead, but be careful!`,
+							text: `🚫 ${danger}\n\nCommand blocked by safety policy. If this is a false positive, ask the user for confirmation or use force: true with explicit user approval.`,
 						},
 					],
 				};

package/src/tools/safe-bash.ts

@@ -4,7 +4,8 @@
  * Uses linear-time scanning to prevent ReDoS attacks
  */
 
-import { Type } from "@sinclair/typebox";
+import { logInternalError } from "../utils/internal-error.ts";
+
 
 // Backward-compatible pattern array (kept for getPatterns API)
 // IMPORTANT: Line 8 (rm pattern with nested quantifiers) has been replaced
@@ -163,6 +164,14 @@ export function isDangerous(command: string, options: SafeBashOptions = {}): str
 
 	if (!enabled) return null;
 
+	// Reject overly permissive allowPatterns that would bypass all safety
+	for (const pattern of allowPatterns) {
+		if (pattern.source === ".*" || (pattern.test("") && pattern.test("rm -rf /"))) {
+			logInternalError("safe-bash.permissive-allow-pattern", new Error(`allowPattern rejects nothing: ${pattern}`));
+			throw new Error(`Overly permissive allowPattern rejected: ${pattern}. Use specific patterns only.`);
+		}
+	}
+
 	// Normalize: remove line continuations, collapse whitespace
 	const normalized = command.replace(/\\\n/g, " ").replace(/\s+/g, " ").trim();
 

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 {

package/src/workflows/workflow-config.ts

@@ -14,6 +14,9 @@ export interface WorkflowStep {
 	progress?: boolean;
 	worktree?: boolean;
 	verify?: boolean;
+	/** Per-step files to overlay into the worktree (in addition to global worktree.seedPaths).
+	 * Useful when only certain steps need access to local drafts or scripts. */
+	seedPaths?: string[];
 }
 
 export interface WorkflowConfig {