pi-crew 0.7.5 → 0.7.7

package/src/ui/card-colors.ts

@@ -14,6 +14,7 @@
  *   30-35% — word-level emphasis (prominent)
  */
 import type { CrewTheme } from "./theme-adapter.ts";
+import { visibleWidth as visualWidth } from "../utils/visual.ts";
 
 // ── ANSI parsing ────────────────────────────────────────────────────────
 
@@ -96,12 +97,15 @@ export function deriveCardBackground(
 
 // ── Helpers for padding lines with a background ─────────────────────────
 
-const ANSI_SGR_RE = /\x1b\[[0-9;]*m/g;
 const RESET = "\x1b[0m";
 
-/** Strip ANSI SGR codes to get visible character count. */
+/** Strip ANSI SGR codes then compute the VISUAL width (Unicode-aware).
+ * Round 23 (BUG 2): previously this used `.length` (UTF-16 code units), which
+ * under-counts CJK/emoji → wrong padding → broken frame borders in crew cards.
+ * Delegate to the canonical Unicode-aware visualWidth from utils/visual.ts
+ * used by every other renderer. */
 export function visibleWidth(text: string): number {
-	return text.replace(ANSI_SGR_RE, "").length;
+	return visualWidth(text);
 }
 
 /**

package/src/ui/dashboard-panes/agents-pane.ts

@@ -3,7 +3,9 @@ import { iconForStatus } from "../status-colors.ts";
 import type { RunUiSnapshot } from "../snapshot-types.ts";
 import { spinnerFrame } from "../spinner.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
+import { formatCost } from "../../state/usage.ts";
 import { listLiveAgents, listLiveAgentsByWorkspace, type LiveAgentHandle } from "../../runtime/live-agent-manager.ts";
+import { computeLiveDurationMs } from "../live-duration.ts";
 
 /**
  * Returns true if this agent did real work (LLM call, tool use, or non-trivial duration).
@@ -82,15 +84,26 @@ export function renderAgentsPane(snapshot: RunUiSnapshot | undefined, options: R
 			: agent.status === "failed" ? (agent.error ?? "failed")
 			: "done";
 
-		// Stats: tokens + duration only
+		// Stats: tokens + cost + duration
 		const stats: string[] = [];
 		const tokenTotal = (agent.usage?.input ?? 0) + (agent.usage?.output ?? 0) + (agent.usage?.cacheRead ?? 0) + (agent.usage?.cacheWrite ?? 0);
 		if (tokenTotal > 0) {
 			const tok = tokenTotal >= 1000 ? `${(tokenTotal / 1000).toFixed(1)}k` : `${tokenTotal}`;
 			stats.push(tok);
 		}
+		// Per-agent cost (Round 17 BS-1): the data is already on task.usage.cost;
+		// surface it live so the user sees $ burn per agent during a run.
+		if (agent.usage?.cost && agent.usage.cost > 0) {
+			stats.push(formatCost(agent.usage.cost));
+		}
 		if (liveHandle) {
-			const ms = (liveHandle.activity.completedAtMs ?? Date.now()) - liveHandle.activity.startedAtMs;
+			// Round 23 (BUG 1): the duration math here was naive —
+			//   (completedAtMs ?? Date.now()) - startedAtMs
+			// which produced a giant NEGATIVE duration whenever startedAtMs was
+			// 0/undefined/bad, or a race set completedAtMs < startedAtMs. This
+			// fired for EVERY running live agent in the dashboard. Use the shared,
+			// validated computeLiveDurationMs (mirrors widget-formatters.ts).
+			const ms = computeLiveDurationMs(liveHandle.activity);
 			stats.push(`${(ms / 1000).toFixed(1)}s`);
 			if (options.showModel !== false && liveHandle.modelName && liveHandle.modelName !== "default") {
 				stats.push(liveHandle.modelName);

package/src/ui/live-duration.ts

@@ -0,0 +1,58 @@
+/**
+ * Round 23 (BUG 1 fix): live-agent duration computation.
+ *
+ * The naive `(completedAtMs ?? Date.now()) - startedAtMs` produced giant
+ * NEGATIVE durations for every running live agent whenever startedAtMs was
+ * 0/undefined/out-of-range, or a race set completedAtMs < startedAtMs.
+ *
+ * This module consolidates the validated duration math (previously duplicated
+ * between widget-formatters.ts and agents-pane.ts) into one pure, fully
+ * testable function: it normalizes seconds-vs-ms, sanity-checks the start
+ * timestamp against the current time, and never returns a negative value.
+ */
+
+export interface LiveActivity {
+	startedAtMs?: number;
+	completedAtMs?: number;
+}
+
+/** Normalize a raw timestamp that may be seconds or milliseconds. */
+function toMs(v: number): number {
+	if (v <= 0) return 0;
+	// 1e9 < seconds < 1e10  → seconds, scale up
+	if (v > 1_000_000_000 && v < 10_000_000_000) return v * 1000;
+	// 1e11 < ms < 1e13      → already ms
+	if (v > 100_000_000_000 && v < 10_000_000_000_000) return v;
+	return v;
+}
+
+/**
+ * Compute the live elapsed duration in milliseconds for an agent activity.
+ *
+ * - Never negative (clamped to >= 0).
+ * - Returns 0 if the start timestamp is missing or implausible.
+ * - Uses `completedAtMs` when present and sane; otherwise `nowMs` (running).
+ *
+ * @param activity the live agent activity handle
+ * @param nowMs    optional override for `Date.now()` (tests / determinism)
+ */
+export function computeLiveDurationMs(activity: LiveActivity, nowMs: number = Date.now()): number {
+	const rawStarted = activity.startedAtMs || 0;
+	const rawCompleted = activity.completedAtMs || 0;
+	const startedMs = toMs(rawStarted);
+	const completedMs = rawCompleted > 0 ? toMs(rawCompleted) : 0;
+	// A valid start is positive, not more than 1 minute in the future, and not
+	// more than ~1000 years in the past (guards against 0 / garbage / clock skew).
+	const isValidStarted =
+		startedMs > 0 &&
+		startedMs < nowMs + 60_000 &&
+		startedMs > nowMs - 31_556_926_000_000;
+	const end = completedMs > 0 && completedMs < nowMs + 60_000 ? completedMs : nowMs;
+	const ms = end - (isValidStarted ? startedMs : nowMs);
+	return Number.isFinite(ms) && ms >= 0 ? ms : 0;
+}
+
+/** Format a live duration in seconds, e.g. `12.3s`. Returns `0.0s` for 0. */
+export function formatLiveDuration(activity: LiveActivity, nowMs: number = Date.now()): string {
+	return `${(computeLiveDurationMs(activity, nowMs) / 1000).toFixed(1)}s`;
+}

package/src/ui/tool-render.ts

@@ -10,6 +10,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";
+import { truncateToWidth } from "../utils/visual.ts";
 
 // ── Types ──────────────────────────────────────────────────────────────
 export interface Theme {
@@ -68,17 +69,12 @@ function formatContextUsage(tokens: number, contextWindow: number | undefined):
 
 export function truncLine(text: string, maxWidth: number): string {
 	if (text.includes("\n") || text.includes("\r")) text = text.replace(/\r?\n/g, "↵ ");
-	if (visibleWidth(text) <= maxWidth) return text;
-	let result = "", width = 0;
-	for (let i = 0; i < text.length; i++) {
-		if (text[i] === "\x1b") {
-			const m = text.slice(i).match(/^\x1b\[[0-9;]*m/);
-			if (m) { result += m[0]; i += m[0].length - 1; continue; }
-		}
-		if (width >= maxWidth - 1) return result + "…";
-		result += text[i]; width++;
-	}
-	return result;
+	// Round 23 (BUG 4): previously this loop counted 1 visual column per UTF-16
+	// code unit and indexed text[i], so for CJK it emitted up to 2x the visual
+	// width (frame overflow) and for emoji it split surrogate pairs (U+FFFD).
+	// Delegate to the grapheme/ANSI-aware truncateToWidth (keeps ANSI codes,
+	// respects double-wide CJK + surrogate pairs, adds the '…' ellipsis).
+	return truncateToWidth(text, maxWidth);
 }
 
 export function formatToolPreview(name: string, args: Record<string, unknown>): string {

package/src/ui/tool-renderers/index.ts

@@ -12,6 +12,7 @@ import type { CrewTheme } from "../theme-adapter.ts";
 import { truncLine, formatTokens, formatDuration } from "../tool-render.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import { isBrief, briefToolResult } from "./brief-mode.ts";
+import { truncateToWidth } from "../../utils/visual.ts";
 
 // ── Types ──────────────────────────────────────────────────────────────
 
@@ -42,9 +43,11 @@ function padVisual(str: string, targetWidth: number): string {
 /** Truncate a string (which may contain ANSI codes) to a target VISUAL width. */
 function truncVisual(str: string, maxWidth: number): string {
 	if (visibleWidth(str) <= maxWidth) return str;
-	// Strip ANSI to truncate safely, then caller re-colors
-	const stripped = str.replace(/\x1b\[[0-9;]*m/g, "");
-	return stripped.slice(0, maxWidth);
+	// Round 23 (BUG 3): previously used String.slice(0, maxWidth) which counts
+	// UTF-16 code units — for CJK that overflows the card by up to 2x, and for
+	// emoji it splits a surrogate pair (U+FFFD). Use the grapheme/ANSI-aware
+	// truncateToWidth with empty ellipsis (the caller appends its own '…').
+	return truncateToWidth(str, maxWidth, "");
 }
 
 // ── Visual primitives ──────────────────────────────────────────────────

package/src/ui/widget/widget-formatters.ts

@@ -7,6 +7,7 @@
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import type { LiveAgentHandle } from "../../runtime/live-agent-manager.ts";
 import { getTaskUsage } from "../../runtime/usage-tracker.ts";
+import { computeLiveDurationMs } from "../live-duration.ts";
 
 // ── Token formatting ──────────────────────────────────────────────────
 
@@ -115,19 +116,7 @@ export function agentStats(agent: CrewAgentRecord, liveHandle?: LiveAgentHandle)
 			const ctxPct = stats?.contextUsage?.percent;
 			if (ctxPct != null) parts.push(`${Math.round(ctxPct)}% ctx`);
 		} catch { /* ignore */ }
-		const rawStarted = act.startedAtMs || 0;
-		const rawCompleted = act.completedAtMs || 0;
-		const nowMs = Date.now();
-		const toMs = (v: number): number => {
-			if (v <= 0) return 0;
-			if (v > 1000000000 && v < 10000000000) return v * 1000;
-			if (v > 100000000000 && v < 10000000000000) return v;
-			return v;
-		};
-		const startedMs = toMs(rawStarted);
-		const completedMs = rawCompleted > 0 ? toMs(rawCompleted) : 0;
-		const isValidStarted = startedMs > 0 && startedMs < nowMs + 60000 && startedMs > nowMs - 3155692600000;
-		const ms = (completedMs > 0 && completedMs < nowMs + 60000 ? completedMs : nowMs) - (isValidStarted ? startedMs : nowMs);
+		const ms = computeLiveDurationMs(act);
 		parts.push(`${(ms / 1000).toFixed(1)}s`);
 	} else {
 		if (agent.toolUses) parts.push(`${agent.toolUses} tools`);

package/src/utils/fs-watch.ts

@@ -1,9 +1,17 @@
 import * as fs from "node:fs";
-import * as path from "node:path";
 import type { FSWatcher, WatchListener } from "node:fs";
 
-/** @internal */
-const FS_WATCH_RETRY_DELAY_MS = 5000;
+/**
+ * Filesystem watcher helpers (slimmed down — pts/2 hang fix 2026-06-16).
+ *
+ * The recursive-watcher helpers (createRecursiveWatcher / watchCrewState /
+ * runIdFromStateRelativePath) were REMOVED: a recursive fs.watch on the run
+ * state tree exploded to O(total run history) inotify watches on Linux and
+ * caused a permanent interactive-session busy-loop. The bounded
+ * {@link RunWatcherRegistry} (one non-recursive watcher per ACTIVE run) now
+ * replaces them. Only the two primitives below survive — they are still used by
+ * manifest-cache, result-watcher, and run-watcher-registry.
+ */
 
 export function closeWatcher(watcher: FSWatcher | null | undefined): void {
 	if (!watcher) {
@@ -31,60 +39,3 @@ export function watchWithErrorHandler(
 		return null;
 	}
 }
-
-/**
- * 1.3 — Watch a directory recursively and invoke `onChange` when any file
- * inside changes. Falls back to `null` on systems where `fs.watch` rejects
- * recursive mode (e.g., Linux when running on older kernels via FUSE/network FS).
- *
- * Callers MUST handle null and fall back to polling. The watcher emits the
- * filename relative to `rootDir` (forward-slash normalised on Windows).
- */
-export function createRecursiveWatcher(
-	rootDir: string,
-	onChange: (relativePath: string) => void,
-	onError: (error: unknown) => void,
-): FSWatcher | null {
-	try {
-		if (!fs.existsSync(rootDir)) fs.mkdirSync(rootDir, { recursive: true });
-		const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
-			if (typeof filename !== "string" || filename.length === 0) return;
-			onChange(filename.replace(/\\/g, "/"));
-		});
-		watcher.on("error", (error) => {
-			try { watcher.close(); } catch { /* ignore */ }
-			onError(error);
-		});
-		return watcher;
-	} catch (error) {
-		onError(error);
-		return null;
-	}
-}
-
-/**
- * Given a path relative to `<crewRoot>/state`, return the runId that owns
- * the change, or undefined if the path doesn't match any tracked run layout.
- */
-export function runIdFromStateRelativePath(relativePath: string): string | undefined {
-	const parts = relativePath.split("/");
-	// Layout is `runs/{runId}/...` — see docs/architecture.md state layer.
-	if (parts.length >= 2 && parts[0] === "runs" && parts[1]) return parts[1];
-	return undefined;
-}
-
-/** Convenience: combine the two helpers for `<crewRoot>/state` watching. */
-export function watchCrewState(
-	stateDir: string,
-	onRunChange: (runId: string) => void,
-	onError: (error: unknown) => void,
-): FSWatcher | null {
-	return createRecursiveWatcher(stateDir, (relativePath) => {
-		const runId = runIdFromStateRelativePath(relativePath);
-		if (runId) onRunChange(runId);
-	}, onError);
-}
-
-// Re-export path helper so callers don't pull node:path just for join.
-/** @internal */
-const joinPath = path.join;

package/src/utils/run-watcher-registry.ts

@@ -0,0 +1,164 @@
+/**
+ * RunWatcherRegistry — bounded per-run filesystem watcher registry.
+ *
+ * PROBLEM (pts/2 interactive-session hang, /home/bom/pts2-hang-investigation-2026-06-16.md):
+ * `watchCrewState` used `fs.watch(<crewRoot>/state, { recursive: true })`. On
+ * Linux, Node implements "recursive" by creating ONE inotify watch PER
+ * SUBDIRECTORY. With many historical runs under `.crew/state/runs/`, this
+ * ballooned to hundreds of watches (109→339 observed) — one per run dir ever —
+ * and the resulting event volume + render amplification produced a permanent
+ * busy-loop (71% CPU, 400KB/s read) even with no active work.
+ *
+ * FIX: instead of recursively watching the whole history, watch a SINGLE
+ * non-recursive watcher on the `runs/` root (to detect new run dirs appearing)
+ * PLUS one non-recursive watcher PER ACTIVE RUN. Total inotify cost is now
+ * O(active runs) — typically 1–5 — not O(total history). Completed runs stop
+ * being watched as soon as they leave the active set (reconciled by buildFrame,
+ * which reads manifest statuses each preload tick).
+ *
+ * The registry is intentionally small and directly unit-testable (a Map of
+ * watchers with add/remove/reconcile/close semantics).
+ */
+import type { FSWatcher } from "node:fs";
+import { closeWatcher, watchWithErrorHandler } from "./fs-watch.ts";
+
+export interface ReconcileResult {
+	added: string[];
+	removed: string[];
+}
+
+export interface ActiveRun {
+	runId: string;
+	runDir: string;
+}
+
+export type RunChangeCallback = (runId: string) => void;
+export type ErrorCallback = (error: unknown) => void;
+
+export class RunWatcherRegistry {
+	private readonly runWatchers = new Map<string, FSWatcher>();
+	private rootWatcher: FSWatcher | undefined;
+	private closed = false;
+
+	/**
+	 * Watch the `runs/` root directory (non-recursive) and invoke `onNewRun`
+	 * whenever a new run subdirectory appears. This is the only way to detect a
+	 * brand-new run, because `crew.run.created` is never emitted by the runtime
+	 * (confirmed: only `crew.run.completed/failed/cancelled` are emitted).
+	 */
+	setRootWatcher(
+		runsDir: string,
+		onNewRun: RunChangeCallback,
+		onError?: ErrorCallback,
+	): void {
+		if (this.closed) return;
+		// Replace any prior root watcher.
+		closeWatcher(this.rootWatcher);
+		this.rootWatcher = watchWithErrorHandler(
+			runsDir,
+			(_eventType, filename) => {
+				if (typeof filename !== "string" || filename.length === 0) return;
+				// fs.watch reports directory entries as bare names (no slash on Linux).
+				// A new run dir appears as `runs/<runId>` → filename = "<runId>".
+				// Filter obviously-not-run-id noise (files, temp, etc.) defensively.
+				const candidate = filename.replace(/\\/g, "/").split("/")[0];
+				if (candidate.length === 0) return;
+				onNewRun(candidate);
+			},
+			(error) => {
+				if (onError) onError(error);
+			},
+		) ?? undefined;
+	}
+
+	/**
+	 * Add a NON-RECURSIVE watcher on a single run directory. Costs exactly ONE
+	 * inotify watch. If a watcher for this runId already exists, close + replace.
+	 * Returns true if a watcher is now active for this runId.
+	 */
+	addRunWatcher(
+		runId: string,
+		runDir: string,
+		onChange: RunChangeCallback,
+		onError?: ErrorCallback,
+	): boolean {
+		if (this.closed) return false;
+		const existing = this.runWatchers.get(runId);
+		if (existing) closeWatcher(existing);
+		const watcher = watchWithErrorHandler(
+			runDir,
+			() => onChange(runId),
+			(error) => {
+				if (onError) onError(error);
+			},
+		);
+		if (watcher) {
+			this.runWatchers.set(runId, watcher);
+			return true;
+		}
+		// watchWithErrorHandler returned null (fs.watch unsupported / dir missing).
+		// Remove any stale entry so hasWatcher() stays honest.
+		this.runWatchers.delete(runId);
+		return false;
+	}
+
+	/** Remove and close a specific run's watcher. No-op if not watched. */
+	removeRunWatcher(runId: string): void {
+		const watcher = this.runWatchers.get(runId);
+		if (watcher) {
+			closeWatcher(watcher);
+			this.runWatchers.delete(runId);
+		}
+	}
+
+	/** Is a run currently being watched? */
+	hasWatcher(runId: string): boolean {
+		return this.runWatchers.has(runId);
+	}
+
+	/**
+	 * Reconcile against the current active-run set: add watchers for active runs
+	 * not yet watched, remove watchers for runs that left the active set. Returns
+	 * which runIds were added / removed (useful for logging + tests).
+	 */
+	reconcile(
+		activeRuns: ActiveRun[],
+		onChange: RunChangeCallback,
+		onError?: ErrorCallback,
+	): ReconcileResult {
+		if (this.closed) return { added: [], removed: [] };
+		const activeIds = new Set(activeRuns.map((r) => r.runId));
+		const added: string[] = [];
+		const removed: string[] = [];
+		// Remove watchers for runs no longer active.
+		for (const runId of [...this.runWatchers.keys()]) {
+			if (!activeIds.has(runId)) {
+				this.removeRunWatcher(runId);
+				removed.push(runId);
+			}
+		}
+		// Add watchers for newly-active runs.
+		for (const { runId, runDir } of activeRuns) {
+			if (!this.runWatchers.has(runId)) {
+				if (this.addRunWatcher(runId, runDir, onChange, onError)) {
+					added.push(runId);
+				}
+			}
+		}
+		return { added, removed };
+	}
+
+	/** Close ALL watchers (per-run + root). Safe to call multiple times. */
+	closeAll(): void {
+		this.closed = true;
+		for (const watcher of this.runWatchers.values()) closeWatcher(watcher);
+		this.runWatchers.clear();
+		closeWatcher(this.rootWatcher);
+		this.rootWatcher = undefined;
+	}
+
+	/** Number of active PER-RUN watchers (excludes the root watcher). */
+	get size(): number {
+		return this.runWatchers.size;
+	}
+}

package/src/workflows/discover-workflows.ts

@@ -11,7 +11,7 @@ export interface WorkflowDiscoveryResult {
 	project: WorkflowConfig[];
 }
 
-const STEP_CONFIG_KEYS = new Set(["role", "dependsOn", "parallelGroup", "output", "reads", "model", "skills", "progress", "worktree", "verify", "task", "seedPaths", "preStepScript", "preStepArgs", "preStepTimeout"]);
+const STEP_CONFIG_KEYS = new Set(["role", "dependsOn", "parallelGroup", "output", "reads", "model", "skills", "progress", "worktree", "verify", "task", "seedPaths", "preStepScript", "preStepArgs", "preStepTimeout", "preStepOptional"]);
 
 function parseStepSection(id: string, body: string): WorkflowStep | undefined {
 	const lines = body.trim().split("\n");
@@ -54,6 +54,7 @@ function parseStepSection(id: string, body: string): WorkflowStep | undefined {
 		preStepScript: config.preStepScript || undefined,
 		preStepArgs: parseCsv(config.preStepArgs) || undefined,
 		preStepTimeout: parseOptionalInteger(config.preStepTimeout) ?? undefined,
+		preStepOptional: config.preStepOptional === "true" || config.preStepOptional === "1",
 	};
 }
 

package/src/workflows/workflow-config.ts

@@ -25,6 +25,11 @@ export interface WorkflowStep {
 	preStepArgs?: string[];
 	/** Timeout in ms for preStepScript. Default: 30000. */
 	preStepTimeout?: number;
+	/** Round 21 (E4): if true, a failing preStepScript does NOT abort the task.
+	 * The failure is logged as a warning and the task proceeds without the
+	 * pre-step output. Use for advisory hooks (e.g. optional test runs) whose
+	 * failure shouldn't block the workflow. Default: false (fail-fast). */
+	preStepOptional?: boolean;
 }
 
 export interface WorkflowConfig {