pi-crew 0.11.8 → 0.11.9

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

@@ -12,9 +12,12 @@ import { formatCount, teamWorkflowLabel } from "./format-helpers.ts";
 import { goalFlagSuffix } from "./goal-flag.ts";
 import { DASHBOARD_KEYS } from "./keybinding-map.ts";
 import { ACTIVE, canopyLine, formatHint, RAIL, type RailSlot, railLine, sectionLine, shortId, statusSlot } from "./rail.ts";
+// L5: the EXTENDED cache interface — the base type in snapshot-types.ts does
+// not declare the paint-path accessor (readForRender) or scheduleRefresh.
+import type { RunSnapshotCache } from "./run-snapshot-cache.ts";
 import type { OverlaySchedulerHandle } from "./shared-overlay-scheduler.ts";
 import { registerOverlayScheduler } from "./shared-overlay-scheduler.ts";
-import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
+import type { RunUiSnapshot } from "./snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "./spinner.ts";
 import { colorizeStatusGlyphs, iconForStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
@@ -79,6 +82,9 @@ export class LiveRunSidebar {
 	private cachedWidth = 0;
 	private cachedSignature = "";
 	private autoCloseTimeout?: NodeJS.Timeout;
+	/** L4 (real-test 2026-10-07): FIXED close deadline (epoch ms), captured
+	 * ONCE on first eligibility — re-renders must never slide it. */
+	private autoCloseDeadline?: number;
 	private hasAutoClosed = false;
 
 	constructor(input: {
@@ -157,10 +163,7 @@ export class LiveRunSidebar {
 		// M-10 fix (code-review 2026-06-23): clear the auto-close timer so a
 		// disposed sidebar (not closed via the normal path) doesn't fire this.done()
 		// on a disposed component.
-		if (this.autoCloseTimeout) {
-			clearTimeout(this.autoCloseTimeout);
-			this.autoCloseTimeout = undefined;
-		}
+		this.clearAutoClose();
 		this.unsubscribeTheme();
 		this.schedulerHandle.dispose();
 	}
@@ -180,8 +183,15 @@ export class LiveRunSidebar {
 		let rawAgents: ReturnType<typeof readCrewAgents>;
 		let snapshot: RunUiSnapshot | undefined;
 		if (this.snapshotCache) {
+			// L5 (real-test 2026-10-07): the paint path reads the cache ONLY.
+			// refreshIfStale rebuilt synchronously between paints (multiple stats +
+			// manifest/tasks parse + sha256), stuttering frame pacing. readForRender
+			// returns the cached snapshot and schedules the COALESCED ASYNC refresh
+			// when the entry's TTL has lapsed; a missing entry schedules nothing, so
+			// kick one here or the pre-load frame below would never fill.
 			try {
-				snapshot = this.snapshotCache.refreshIfStale(this.runId);
+				snapshot = this.snapshotCache.readForRender(this.runId);
+				if (!snapshot) this.snapshotCache.scheduleRefresh(this.runId);
 			} catch {
 				snapshot = undefined;
 			}
@@ -331,25 +341,29 @@ export class LiveRunSidebar {
 			}
 			// F-6: compute the auto-close countdown BEFORE the cap so the countdown
 			// renders inside the frame rather than below it.
-			// Auto-close logic: if run is terminal and no active agents, close after delay
+			// Auto-close logic: if run is terminal and no active agents, close after delay.
+			// L4 (real-test 2026-10-07): the deadline is captured ONCE on FIRST
+			// eligibility and never re-armed while eligibility persists. The old code
+			// did clearTimeout+setTimeout(full delay) on every fresh render, so any
+			// trailing event < autoCloseMs apart slid the deadline forever and the
+			// countdown froze while the sidebar stayed open indefinitely.
 			const isTerminal = ["completed", "failed", "cancelled", "blocked"].includes(run.status);
 			const hasActiveAgents = agents.some((a) => a.status === "running");
 			if (isTerminal && !hasActiveAgents && !this.hasAutoClosed) {
 				const autoCloseMs = this.config?.autoCloseDashboardMs ?? 3000;
 				if (autoCloseMs > 0) {
-					if (this.autoCloseTimeout) clearTimeout(this.autoCloseTimeout);
-					this.autoCloseTimeout = setTimeout(() => {
-						this.hasAutoClosed = true;
-						this.done(undefined);
-					}, autoCloseMs);
-					this.autoCloseTimeout?.unref();
-					lines.push(this.bodyRow(this.theme.fg("dim", `auto-close in ${Math.round(autoCloseMs / 1000)}s…`), budget));
+					if (this.autoCloseDeadline === undefined) {
+						this.autoCloseDeadline = Date.now() + autoCloseMs;
+						this.armAutoClose(this.autoCloseDeadline);
+					}
+					const remainingMs = Math.max(0, this.autoCloseDeadline - Date.now());
+					lines.push(this.bodyRow(this.theme.fg("dim", `auto-close in ${Math.ceil(remainingMs / 1000)}s…`), budget));
 				}
-			}
-			// Clear timeout if conditions change
-			else if (this.autoCloseTimeout) {
-				clearTimeout(this.autoCloseTimeout);
-				this.autoCloseTimeout = undefined;
+			} else {
+				// Off the terminal window (run resumed, active agents (re)appeared) or
+				// already closed: cancel AND forget the deadline — the NEXT eligibility
+				// captures a fresh one. hasAutoClosed keeps done() from re-arming.
+				this.clearAutoClose();
 			}
 			this.cachedLines = renderLines(this.renderFrame(lines, budget, slot), w);
 			this.cachedSignature = signature;
@@ -363,13 +377,69 @@ export class LiveRunSidebar {
 		return railLine(RAIL.body, "border", content, this.theme, budget);
 	}
 
-	/** Append the `┗ <hint>` cap and colorize the glyphs (F-1 / V-3). */
+	/** L4: arm the close callback for a FIXED deadline. Re-renders never touch
+	 * it, so the close lands at firstEligibility + autoCloseMs regardless of
+	 * how many trailing events repaint the frame in between. */
+	private armAutoClose(deadline: number): void {
+		if (this.autoCloseTimeout) clearTimeout(this.autoCloseTimeout);
+		this.autoCloseTimeout = setTimeout(
+			() => {
+				this.hasAutoClosed = true;
+				this.done(undefined);
+			},
+			Math.max(0, deadline - Date.now()),
+		);
+		this.autoCloseTimeout?.unref();
+	}
+
+	/** L4: cancel the fixed deadline — only a NEW eligibility re-arms it. */
+	private clearAutoClose(): void {
+		if (this.autoCloseTimeout) {
+			clearTimeout(this.autoCloseTimeout);
+			this.autoCloseTimeout = undefined;
+		}
+		this.autoCloseDeadline = undefined;
+	}
+
+	/** Append the `┗ <hint>` cap, lock the frame to ONE stable height (L6)
+	 * and colorize the glyphs (F-1 / V-3). */
 	private renderFrame(lines: string[], budget: number, slot: RailSlot): string[] {
 		const hint = this.theme.fg("dim", formatHint(SIDEBAR_HINT));
 		const framed = [...lines, railLine(RAIL.close, slot, hint, this.theme, budget)];
+		this.lockHeight(framed, budget);
 		return framed.map((entry) => this.colorLine(entry));
 	}
 
+	/**
+	 * L6 (real-test 2026-10-07): pad with blank rail rows (cap stays LAST) or
+	 * slice (cap preserved) so EVERY frame — the 3-line pre-load frame and the
+	 * 20+ line loaded frame — is exactly targetHeight() lines. The host
+	 * positions overlays by the returned line count; a frame that flips
+	 * between heights moves the anchor row and the differential renderer
+	 * leaves a ghost footprint below the sidebar. Same contract as
+	 * run-dashboard's targetHeight() clamp.
+	 */
+	private lockHeight(lines: string[], budget: number): void {
+		const target = this.targetHeight();
+		if (lines.length < target) {
+			const blankRow = railLine(RAIL.body, "border", "", this.theme, budget);
+			const bottom = lines.pop();
+			while (lines.length < target - 1) lines.push(blankRow);
+			if (bottom !== undefined) lines.push(bottom);
+		} else if (lines.length > target) {
+			const bottom = lines[lines.length - 1];
+			lines.length = target - 1;
+			lines.push(bottom);
+		}
+	}
+
+	/** L6: stable overlay height — clamped like run-dashboard's targetHeight()
+	 * but scaled for the sidebar's single column (12–30 instead of 12–36). */
+	private targetHeight(): number {
+		const rows = Number.isFinite(process.stdout?.rows) ? Number(process.stdout?.rows) : 30;
+		return Math.max(12, Math.min(30, rows - 2));
+	}
+
 	handleInput(data: string): void {
 		if (data === "q" || data === "\u001b") this.done(undefined);
 	}

package/src/ui/overlays/mailbox-compose-overlay.ts

@@ -23,7 +23,7 @@
  * from `formatHint` (discard LAST, keys through `keyToken`).
  */
 
-import { CURSOR_MARKER } from "@earendil-works/pi-tui";
+import * as piTui from "@earendil-works/pi-tui";
 import type { MailboxDirection } from "../../state/coordination/mailbox.ts";
 import { pad, sanitizeLine, truncate } from "../../utils/visual.ts";
 import { overlayActionForKey } from "../keybinding-map.ts";
@@ -32,6 +32,22 @@ import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
 import { ConfirmOverlay } from "./confirm-overlay.ts";
 import { renderComposePreview } from "./mailbox-compose-preview.ts";
 
+/** Resolve pi-tui's zero-width IME cursor anchor defensively (L8, policy
+ *  W4/G22) — same typeof-guard shape as hyperlink() at widget-renderer.ts:
+ *  118-128 and the sibling resolver in settings-overlay.ts. The peer range is
+ *  `*`, so a host running a pi-tui build without the export must still render
+ *  instead of failing the named import at link time. Exported for the
+ *  fallback pin in test/unit/ui/settings-overlay-cursor-marker.test.ts. */
+export function resolveCursorMarker(mod: unknown): string {
+	const candidate = (mod as { CURSOR_MARKER?: unknown }).CURSOR_MARKER;
+	return typeof candidate === "string" ? candidate : "";
+}
+
+/** "" on hosts whose pi-tui predates CURSOR_MARKER — the active field then
+ *  renders without the IME anchor (marker is zero-width, stripped before
+ *  painting; pure enhancement, never a layout dependency). */
+const CURSOR_MARKER = resolveCursorMarker(piTui);
+
 export interface MailboxComposePayload {
 	from: string;
 	to: string;

package/src/ui/run-action-dispatcher.ts

@@ -19,6 +19,7 @@ import type { MailboxDirection, MailboxMessage } from "../state/coordination/mai
 import { appendEventBuffered } from "../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunTasks } from "../state/stores/state-store.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { formatCount } from "./format-helpers.ts";
 
 export interface RunActionResult {
 	ok: boolean;
@@ -107,7 +108,7 @@ export async function dispatchMailboxAckAll(ctx: ExtensionContext, runId: string
 	}
 	return {
 		ok: true,
-		message: `Acknowledged ${count} messages.`,
+		message: `Acknowledged ${formatCount(count, "message")}.`,
 		data: { count },
 	};
 }

package/src/ui/run-dashboard.ts

@@ -28,7 +28,7 @@ import { renderPlanPane } from "./dashboard-panes/plan-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderScheduleDetails, renderSchedulesPane } from "./dashboard-panes/schedules-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
-import { formatCount, teamWorkflowLabel } from "./format-helpers.ts";
+import { formatCount, formatDuration, formatTokens, teamWorkflowLabel } from "./format-helpers.ts";
 import { goalFlagSuffix } from "./goal-flag.ts";
 import { type DashboardKeyAction, dashboardActionForKey } from "./keybinding-map.ts";
 import { HelpOverlay } from "./overlays/help-overlay.ts";
@@ -228,14 +228,14 @@ function runListWindow(scrollOffset: number, count: number): RunListWindow {
 	return { slots, hasTop, hasBottom };
 }
 
+/** L7 (real-test 2026-10-07): agent age in the shared formatDuration dialect
+ *  (`5m44s`), rendered bare — the retired `age=` prefix was wire format.
+ *  Sub-second ages read `now` (quieter than `123ms` on a rail row). */
 function formatAge(iso: string | undefined): string | undefined {
 	if (!iso) return undefined;
 	const ms = Math.max(0, Date.now() - new Date(iso).getTime());
 	if (!Number.isFinite(ms)) return undefined;
-	if (ms < 1000) return "now";
-	if (ms < 60_000) return `${Math.floor(ms / 1000)}s`;
-	if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m`;
-	return `${Math.floor(ms / 3_600_000)}h`;
+	return ms < 1000 ? "now" : formatDuration(ms);
 }
 
 function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?: RunSnapshotCache, resolve?: SnapshotResolver): string[] {
@@ -271,17 +271,21 @@ function readProgressPreview(run: TeamRunManifest, maxLines = 5, snapshotCache?:
 	}
 }
 
-function formatTokens(usage: UsageState | undefined): string | undefined {
+/**
+ * L7 (real-test 2026-10-07): TUI usage dialect — `↑1.0k ↓250 $0.012` —
+ * mirroring the compactUsage pattern in live-run-sidebar.ts (kept local
+ * because the sidebar's helper is module-private; do not edit that file).
+ * Replaces the retired `tok=…/in=…/out=…/cache=…/$…` wire format, which
+ * leaked log-line grammar onto rail rows and buried the numbers behind
+ * key=value prefixes. cacheRead/cacheWrite stay hidden (sidebar parity).
+ */
+function compactUsage(usage: UsageState | undefined): string | undefined {
 	if (!usage) return undefined;
-	const total = (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
-	if (!total) return undefined;
-	const compact = total >= 1000 ? `${(total / 1000).toFixed(total >= 10_000 ? 0 : 1)}k` : `${total}`;
-	const parts = [`tok=${compact}`];
-	if (usage.input) parts.push(`in=${usage.input}`);
-	if (usage.output) parts.push(`out=${usage.output}`);
-	if (usage.cacheRead) parts.push(`cache=${usage.cacheRead}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join("/");
+	const parts: string[] = [];
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(3)}`);
+	return parts.length ? parts.join(" ") : undefined;
 }
 
 function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): RunUiSnapshot | undefined {
@@ -292,6 +296,38 @@ function snapshotFor(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): Ru
 	}
 }
 
+/**
+ * L5 (real-test 2026-10-07): paint-path snapshot read for the frame-local
+ * SnapshotResolver in `renderUnsafe`. Uses the cache's `readForRender`
+ * accessor when present — cached snapshot ONLY; a lapsed TTL schedules the
+ * coalesced async refresh off the paint path; a missing entry schedules one
+ * refresh so the pre-load rows fill on a later frame (sidebar precedent,
+ * live-run-sidebar.ts render()). Feature-detected because
+ * `RunDashboardOptions.snapshotCache` keeps the BASE interface
+ * (snapshot-types.ts): production wires the extended cache, while test mocks
+ * and legacy callers may implement only get/refreshIfStale — for those a
+ * plain get() keeps the render read-only. Keypress handlers and other
+ * read-your-writes sites keep `snapshotFor()` (sync refreshIfStale) — Tier 11a.
+ */
+function snapshotForRender(run: TeamRunManifest, snapshotCache?: RunSnapshotCache): RunUiSnapshot | undefined {
+	const cache = snapshotCache as
+		| (RunSnapshotCache & {
+				readForRender?: (runId: string) => RunUiSnapshot | undefined;
+				scheduleRefresh?: (runId: string) => void;
+		  })
+		| undefined;
+	if (typeof cache?.readForRender === "function") {
+		try {
+			const snapshot = cache.readForRender(run.runId);
+			if (!snapshot && typeof cache.scheduleRefresh === "function") cache.scheduleRefresh(run.runId);
+			return snapshot;
+		} catch {
+			return snapshotCache?.get(run.runId);
+		}
+	}
+	return snapshotCache?.get(run.runId);
+}
+
 /**
  * PERF (2026-08-24, task 20) — per-frame snapshot resolver. The render path
  * used to resolve each run's snapshot 6-8 times per frame (refreshRuns,
@@ -344,16 +380,16 @@ function usageForAgent(agent: CrewAgentRecord, task: TeamTaskState | undefined):
 function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefined, options: RunDashboardOptions): string {
 	const stats = [
 		agent.progress?.activityState,
-		options.showModel !== false && modelForAgent(agent, task) ? `model=${modelForAgent(agent, task)}` : undefined,
+		options.showModel !== false ? modelForAgent(agent, task) : undefined,
 		options.showTokens !== false
-			? (formatTokens(usageForAgent(agent, task)) ??
-				(agent.progress?.tokens !== undefined ? `tok=${agent.progress.tokens}` : undefined))
+			? (compactUsage(usageForAgent(agent, task)) ??
+				(agent.progress?.tokens !== undefined ? `↑${formatTokens(agent.progress.tokens)}` : undefined))
 			: undefined,
 		options.showTools !== false && agent.progress?.currentTool ? `tool=${agent.progress.currentTool}` : undefined,
 		options.showTools !== false && agent.toolUses !== undefined ? formatCount(agent.toolUses, "tool") : undefined,
-		agent.progress?.turns !== undefined ? `${agent.progress.turns} turns` : undefined,
+		agent.progress?.turns !== undefined ? formatCount(agent.progress.turns, "turn") : undefined,
 		agent.progress?.failedTool ? `failedTool=${agent.progress.failedTool}` : undefined,
-		agent.startedAt ? `age=${formatAge(agent.completedAt ?? agent.startedAt)}` : undefined,
+		agent.startedAt ? formatAge(agent.completedAt ?? agent.startedAt) : undefined,
 	].filter((part): part is string => Boolean(part));
 	const recent = agent.progress?.recentOutput?.at(-1);
 	const icon = iconForStatus(agent.status, {
@@ -394,7 +430,8 @@ function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashbo
 				cost: number;
 			},
 		);
-		const header = formatTokens(totals) ? `Agents: ${formatTokens(totals)}` : "Agents:";
+		const usage = compactUsage(totals);
+		const header = usage ? `Agents: ${usage}` : "Agents:";
 		return [
 			header,
 			...agents.slice(0, maxLines).map((agent) => agentPreviewLine(agent, taskForAgent(tasks, agent), options)),
@@ -834,9 +871,12 @@ export class RunDashboard implements DashboardComponent {
 		// PERF (2026-08-24): snapshot resolution stat'd 7-8 files per run 6-8
 		// times per frame. Resolve once per frame into a local map and thread
 		// it through every render-path consumer below.
+		// L5 (real-test 2026-10-07): the resolver reads the cache ONLY
+		// (snapshotForRender → readForRender) — the sync refreshIfStale rebuild
+		// moved off the paint path; refreshes are coalesced + async.
 		const frameSnapshots = new Map<string, RunUiSnapshot | undefined>();
 		const snapshotOnce: SnapshotResolver = (run) => {
-			if (!frameSnapshots.has(run.runId)) frameSnapshots.set(run.runId, snapshotFor(run, this.options.snapshotCache));
+			if (!frameSnapshots.has(run.runId)) frameSnapshots.set(run.runId, snapshotForRender(run, this.options.snapshotCache));
 			return frameSnapshots.get(run.runId);
 		};
 		this.refreshRuns(snapshotOnce);

package/src/ui/run-snapshot-cache.ts

@@ -27,6 +27,14 @@ export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadAllStale(runIds: string[]): Promise<void>;
 	/** Task 17 (perf/review-2026-08-24): watcher-facing coalesced async refresh. */
 	scheduleRefresh(runId: string): void;
+	/**
+	 * L5 (real-test 2026-10-07): paint-path read — cached snapshot only.
+	 * NEVER sync-rebuilds: a lapsed TTL schedules the coalesced async refresh
+	 * (scheduleRefresh pipeline) instead of rebuilding on the paint path, and a
+	 * missing entry returns undefined without building. See the method doc on
+	 * the implementation for the staleness/Tier-11a contract.
+	 */
+	readForRender(runId: string): RunUiSnapshot | undefined;
 	/**
 	 * F13 (RR-018): true once dispose() has run. Callers that retain the cache
 	 * (RegistrationContext.getManifestCache/getRunSnapshotCache) use this to
@@ -1149,6 +1157,30 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		scheduleRefresh(runId: string): void {
 			scheduleCoalescedRefresh(runId);
 		},
+		/**
+		 * L5 (real-test 2026-10-07): read for the paint path. Returns the
+		 * CACHED snapshot (touching LRU/access) and NEVER sync-rebuilds — no
+		 * manifest/tasks parse, no agents.json read, no sha256 between paints.
+		 * When the entry's TTL has lapsed (the read-time proxy for "stamps may
+		 * look stale"), it schedules the EXISTING coalesced async refresh
+		 * (scheduleRefresh → 80ms coalesce → preloadStale); the actual stamp
+		 * comparison happens inside preloadStale, where a stamp-equal hit just
+		 * re-stamps the entry (no rebuild), so a quiet run costs one async stat
+		 * round per TTL window, off the paint path. A missing entry returns
+		 * undefined without building and without scheduling — callers render
+		 * their loading state and may call scheduleRefresh()/preloadStale()
+		 * themselves when they want the entry filled.
+		 * Tier 11a (read-your-writes) is preserved: refresh()/refreshIfStale()
+		 * below keep their sync build paths untouched for callers with a sync
+		 * reader immediately after write.
+		 */
+		readForRender(runId: string): RunUiSnapshot | undefined {
+			const entry = entries.get(runId);
+			if (!entry) return undefined;
+			const snapshot = touch(runId, entry);
+			if (Date.now() - entry.loadedAtMs >= ttlMs) scheduleCoalescedRefresh(runId);
+			return snapshot;
+		},
 		preloadStale,
 		preloadAllStale,
 		invalidate(runId?: string): void {

package/src/ui/settings-overlay.ts

@@ -4,13 +4,34 @@
  * label/value alignment, inline toggle, select submenu, and text input.
  */
 
-import { CURSOR_MARKER } from "@earendil-works/pi-tui";
+import * as piTui from "@earendil-works/pi-tui";
 import { truncateToWidth, visibleWidth } from "../utils/visual.ts";
 import { keyOf, matchesKey } from "./key-utils.ts";
 import { CURSOR, canopyLine, formatHint, overflowHint, RAIL, railLine } from "./rail.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { discoverPiThemes, getActivePiTheme } from "./theme-discovery.ts";
 
+// ---------------------------------------------------------------------------
+// pi-tui CURSOR_MARKER — defensive resolve (L8, policy W4/G22)
+// ---------------------------------------------------------------------------
+
+/** Resolve pi-tui's zero-width IME cursor anchor (APC `ESC _ pi:c BEL`) from
+ *  a pi-tui namespace object. Modeled on the hyperlink() typeof-guard at
+ *  widget/widget-renderer.ts:118-128: the peer range is `*`, so a host
+ *  running a pi-tui build without the export must still render instead of
+ *  failing the named import at link time. Non-string exports are treated as
+ *  missing (contract drift, not a marker). Exported for the fallback pin in
+ *  test/unit/ui/settings-overlay-cursor-marker.test.ts. */
+export function resolveCursorMarker(mod: unknown): string {
+	const candidate = (mod as { CURSOR_MARKER?: unknown }).CURSOR_MARKER;
+	return typeof candidate === "string" ? candidate : "";
+}
+
+/** "" on hosts whose pi-tui predates CURSOR_MARKER — text-input rows then
+ *  render without the IME anchor (the marker is an enhancement, never a
+ *  layout dependency: zero-width, stripped by visibleWidth). */
+const CURSOR_MARKER = resolveCursorMarker(piTui);
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -378,7 +399,10 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"ui.showModel": true,
 	"ui.showTokens": true,
 	"ui.showTools": true,
-	"ui.dashboardPlacement": "center",
+	// L3 (2026-10-07): mirrors DEFAULT_UI.dashboardPlacement = "right"
+	// (defaults.ts) — G17: duplicated EFFECTIVE_DEFAULTS maps must track the
+	// canonical default or the overlay shows a stale value to unset keys.
+	"ui.dashboardPlacement": "right",
 	"ui.dashboardWidth": 72,
 	"ui.autoOpenDashboard": false,
 	// G17 sync (2026-09-10 review): canonical DEFAULT_UI.widgetPlacement =

package/src/ui/tool-renderers/brief-mode.ts

@@ -7,7 +7,7 @@
  */
 
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
-import { formatDuration, formatTokens, truncLine } from "../format-helpers.ts";
+import { formatCount, formatDuration, formatTokens, truncLine } from "../format-helpers.ts";
 import { spinnerClockNow } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
 
@@ -100,7 +100,7 @@ function briefTeam(result: { content?: unknown[] }, theme: CrewTheme): string {
 		const total = records.length;
 		const duration = computeTotalDuration(records);
 		const tokens = computeTotalTokens(records);
-		return `${icon} ${completed}/${total} tasks · ${formatDuration(duration)} · ${formatTokens(tokens)} tok`;
+		return `${icon} ${completed}/${formatCount(total, "task")} · ${formatDuration(duration)} · ${formatTokens(tokens)} tok`;
 	}
 
 	// Fallback: compact status line

package/src/ui/transcript-viewer.ts

@@ -304,7 +304,10 @@ function renderViewerBase(state: ViewerState, width: number, lines: string[], ti
 	// and the full-wrap branch keep the exact count).
 	const totalLines = tailWindow ? skippedCount + visible.length : visualLines.length;
 	const totalLabel = tailWindow && skippedCount > 0 ? `≥ ${totalLines}` : `${totalLines}`;
-	const statusLine = `${totalLabel} lines · ${totalLines ? Math.round(((state.scroll + visible.length) / totalLines) * 100) : 100}% · auto-scroll ${state.autoScroll ? "on" : "off"}`;
+	// L-plural (2026-10-08): "1 lines" grammar slip live-caught in the transcript
+	// viewer footer — pluralize only from 2 (and keep "≥" prefix intact).
+	const linesWord = totalLines === 1 ? "line" : "lines";
+	const statusLine = `${totalLabel} ${linesWord} · ${totalLines ? Math.round(((state.scroll + visible.length) / totalLines) * 100) : 100}% · auto-scroll ${state.autoScroll ? "on" : "off"}`;
 	// RAIL frame (design system §2.E): `┏ NAME ▸ SUBJECT` canopy, `┃` body rows,
 	// `┗ <outcome/hint>` close. The rounded `╭─╮│╰─╯` box is retired. This
 	// viewer is a standalone overlay that paints its own frame, so the rail

package/src/ui/widget/index.ts

@@ -322,13 +322,21 @@ class CrewWidgetComponent implements WidgetComponent {
 		// Task-list variant: the run's plan above the editor (task-list.ts).
 		// No panel state, no spinner glyph — the list changes only on task
 		// transitions, which the run signature already covers.
+		// L-plan-flicker (2026-10-07): `sigBase` carries `:spin=<bucket>` while
+		// any worker runs — keying this variant on it rebuilt the whole card
+		// every 160ms spinner bucket. Strip the animation fragment: the tasks
+		// card paints no animated glyph (task-list.ts running row is a static ▶),
+		// so a bucket change can never change its output. Live effect measured
+		// in the owner session: content diffs dropped from 544/599 samples at
+		// 0.2s to state-transition-rate only.
 		if (this.variant === "tasks") {
-			if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
+			const tasksSignature = `${sigBase.replace(/:spin=\d+$/, "")}:${this.model.notificationCount ?? 0}`;
+			if (this.cacheSignature !== tasksSignature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
 				this.cachedBaseLines = buildTaskListLines(runs, width, this.theme);
 				this.cachedLines = this.colorize(this.cachedBaseLines, width);
 				this.cachedWidth = width;
 				this.cachedTheme = this.theme;
-				this.cacheSignature = signature;
+				this.cacheSignature = tasksSignature;
 				this.lastTruncateWidth = -1;
 			}
 			if (runs.length === 0) {

package/src/ui/widget/task-list.ts

@@ -29,7 +29,6 @@ import type { TeamTaskState } from "../../state/types.ts";
 import { visibleWidth } from "../../utils/visual.ts";
 import { formatCount } from "../format-helpers.ts";
 import { canopyLine, gaugeBar, overflowHint, RAIL, railLine, statusSlot } from "../rail.ts";
-import { spinnerFrame } from "../spinner.ts";
 import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
 import { shortRunLabel } from "./widget-model.ts";
 import type { WidgetRun } from "./widget-types.ts";
@@ -62,12 +61,21 @@ function taskTitle(task: TeamTaskState): string {
 	return (task.displayName ?? task.title ?? "").replace(/\s+/g, " ").trim();
 }
 
-/** pi-tasks status glyph per row: ✔ done (struck through), spinner for the
- *  actively executing task, ◼ parked/needs input, ◻ queued, ✗ dead. */
+/** pi-tasks status glyph per row: ✔ done (struck through), ▶ the actively
+ * executing task, ◼ parked/needs input, ◻ queued, ✗ dead.
+ *
+ * L-plan-flicker (2026-10-07 live probe, 600 frames @0.2s in the owner
+ * session): the running row previously painted `spinnerFrame()` — a braille
+ * frame rotating every 160ms — turning the whole card into a ~8Hz repaint
+ * above the editor ("nháy nháy liên tục"). The plan card is a LIST: per the
+ * variant's own design comment it must change only on task transitions, so
+ * the running glyph is STATIC (like ◼/◻) and the elapsed suffix carries
+ * liveness at 1s grain. The dock keeps its spinner — one animated row is
+ * intentional there. */
 function taskStatusIcon(task: TeamTaskState): string {
 	switch (task.status) {
 		case "running":
-			return spinnerFrame("crew-task-list");
+			return "▶";
 		case "queued":
 			return "◻";
 		case "waiting":

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

@@ -55,10 +55,11 @@ export function activeWidgetRuns(
 		}
 	}
 
-	let runs = preloadedManifests ?? (manifestCache ? manifestCache.list(20) : listRecentRuns(cwd, 20));
-	if (workspaceId) {
-		runs = runs.filter((run) => !run.ownerSessionId || run.ownerSessionId === workspaceId);
-	}
+	// L1 (ui-instability review 2026-10-07): the dock renders in EVERY session, so
+	// NO ownerSessionId display filter here — bystander terminals must see runs
+	// owned by other sessions (live evidence: 308 frames / 0 dock rendered).
+	// workspaceId stays in scope: crash recovery below is still session-scoped.
+	const runs = preloadedManifests ?? (manifestCache ? manifestCache.list(20) : listRecentRuns(cwd, 20));
 
 	return runs
 		.map((run) => {