pi-crew 0.10.6 → 0.11.1

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

@@ -4,30 +4,22 @@
  * Extracted from crew-widget.ts.
  */
 
+import { getCrewScheduler, getScheduledJobs, getScheduledJobsHiddenCountView } from "../../extension/team-tool/handle-schedule.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
-import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
 import { isPlanApprovalStatePending } from "../../runtime/plan-approval.ts";
 import { isFinishedRunStatus } from "../../runtime/process-status.ts";
-import type { TeamRunManifest } from "../../state/types.ts";
-import { truncate } from "../../utils/visual.ts";
+import type { ScheduledJob } from "../../runtime/scheduling/scheduler.ts";
+import { formatRelativeTime } from "../../utils/relative-time.ts";
+import { truncate, visibleWidth } from "../../utils/visual.ts";
 import { Box, Text } from "../layout-primitives.ts";
+import { ACTIVE, RAIL, type RailSlot, railLeaders, railRaw, shortId, statusSlot } from "../rail.ts";
 import { spinnerFrame } from "../spinner.ts";
-import { colorizeStatusGlyphs, iconForStatus } from "../status-colors.ts";
-import type { CrewTheme } from "../theme-adapter.ts";
-import {
-	agentActivity,
-	agentStats,
-	budgetedRow,
-	dockElapsed,
-	dockStatusIcon,
-	dockStatusLabel,
-	dockUsageText,
-	notificationBadge,
-} from "./widget-formatters.ts";
+import { colorizeStatusGlyphs } from "../status-colors.ts";
+import { asCrewTheme, type CrewTheme } from "../theme-adapter.ts";
+import { notificationBadge } from "./widget-formatters.ts";
 import { activeWidgetRuns, shortRunLabel } from "./widget-model.ts";
 import type { WidgetRun } from "./widget-types.ts";
 
-export const MAX_AGENTS_DISPLAY = 3;
 const FINISHED_LINGER_MAX_AGE = 1;
 /** Default terminal width when caller doesn't pass one explicitly. Keep <= 116
  * (the same default used elsewhere in pi-crew tool renderers) so we never paint
@@ -39,19 +31,158 @@ export const TASK_DESC_MAX = 60;
 const ERROR_LINGER_MAX_AGE = 2;
 const ERROR_STATUSES = new Set(["failed", "cancelled", "stopped", "needs_attention"]);
 
+// ── RAIL dock composition (design system §2.B) ─────────────────────────
+//
+// The dock is the ONE surface that must never grow a second row: it speaks the
+// rail grammar with the BODY glyph (`┃`) only — never `┏`/`┗`, which imply a
+// multi-line card. The builders below return PLAIN text (that is the exported
+// contract: `buildWidgetLines` is the raw row, `colorWidgetLine` the paint
+// pass), but they COMPOSE through the shared rail helpers with a no-op theme
+// so the glyph/leader vocabulary lives in `rail.ts` alone.
+const PLAIN_THEME = asCrewTheme(undefined);
+
+/** Identity word of the dock + status bar. */
+const DOCK_WORD = "CREW";
+
+/** The dock's tail: four leaders + the one-key entry hint. */
+const DOCK_HINT_RIGHT = "↓·enter";
+const DOCK_HINT = `···· ${DOCK_HINT_RIGHT}`;
+
+/** The dock's FOCUS marker (RAIL §2.B: "focused row keeps the `❯ ` prefix").
+ *  It is deliberately not `rail.ts`'s `CURSOR` (`›`) — that glyph marks the
+ *  selected row of a LIST; the dock is a single line, and `❯` is the marker
+ *  the prompt area has always acknowledged the ↓ keystroke with. */
+const FOCUS_MARKER = "❯";
+
+/**
+ * `···· ↓·enter` appended to a dock row. Composed through `railLeaders` with a
+ * budget that pins the leader run at exactly four dots — the dock is a
+ * left-aligned single row, so the leaders must NOT stretch to the terminal
+ * width the way a card's metrics→elapsed leaders do.
+ */
+function dockTail(left: string, theme: CrewTheme, maxWidth?: number): string {
+	const pinned = visibleWidth(left) + visibleWidth(DOCK_HINT_RIGHT) + 6;
+	// The pin gives a fixed four-dot leader on a wide terminal. On a NARROW one
+	// the budget shrinks instead, so `railLeaders` trims the LEFT segment (with
+	// `…`) and the actionable `↓·enter` hint never gets clipped away — the live
+	// row used to end in `↓…` at 50 columns.
+	const budget = maxWidth === undefined ? pinned : Math.min(pinned, maxWidth - 2);
+	return railLeaders(left, DOCK_HINT_RIGHT, budget, theme);
+}
+
+/** `CREW ▸ <subject>` — the dock identity (colour is applied on the paint pass). */
+function dockIdentity(subject: string): string {
+	return subject ? `${DOCK_WORD} ${ACTIVE} ${subject}` : DOCK_WORD;
+}
+
+/** `┃ <content>` — the dock rail, unpadded (`truncate` stays the single clip). */
+function dockLine(content: string, theme: CrewTheme, slot: RailSlot): string {
+	return railRaw(RAIL.body, slot, content, theme);
+}
+
+/**
+ * Aggregate run status → the dock's rail colour (§2.B: rail colour = state).
+ * A failure outranks live work; live work outranks idle. Zero runs is idle.
+ */
+export function widgetRailSlot(runs: readonly WidgetRun[]): RailSlot {
+	if (runs.length === 0) return "border";
+	const slots = runs.map((entry) => statusSlot(entry.run.status));
+	if (slots.includes("error")) return "error";
+	if (slots.includes("borderAccent")) return "borderAccent";
+	return slots[0] ?? "border";
+}
+
+/** `<team>` (or `team/workflow` when they differ); several live runs collapse
+ *  to `<n> runs` — the counts on the row stay aggregate. */
+function dockSubject(runs: WidgetRun[]): string {
+	if (runs.length > 1) return `${runs.length} runs`;
+	const first = runs[0];
+	return first ? shortRunLabel(first.run) : "idle";
+}
+
+/**
+ * The zero-run dock row: `┃ CREW ▸ idle · ⏰ 1 sched ···· ↓·enter`.
+ *
+ * Returns `undefined` when nothing schedules-related paints. The keep-alive
+ * path MUST then render NOTHING (`[]`) — a bare hint, and above all the
+ * literal `undefined — ↓·enter`, is the live regression this guards against.
+ */
+export function idleWidgetLine(schedLine: string | undefined, focused = false, maxWidth?: number): string | undefined {
+	if (!schedLine) return undefined;
+	const left = `${dockIdentity("idle")} · ${schedLine}`;
+	const line = dockLine(dockTail(left, PLAIN_THEME, maxWidth), PLAIN_THEME, "border");
+	return focused ? `${FOCUS_MARKER} ${line}` : line;
+}
+
+/**
+ * The dock's leading activity glyph: a braille spinner ONLY while something is
+ * actually running, otherwise the outcome glyph of the aggregate state.
+ *
+ * Live-run bug (2026-09-16): the dock spun forever because `buildWidgetLines`
+ * always passed `spinnerFrame("widget-header")` — a finished run painted
+ * `┃ ⠹ CREW ▸ fast-fix · 0 running · 3/3 done`, i.e. a spinner with nothing to
+ * spin for. `✓`/`✗` are used (not `●`/`✖`) because they are in
+ * `STATUS_GLYPH_CHARS`, so the shared colorizer paints them.
+ */
+export function widgetActivityGlyph(runs: readonly WidgetRun[]): string {
+	const anyAgentRunning = runs.some((entry) => entry.agents.some((agent) => agent.status === "running"));
+	const anyRunRunning = runs.some((entry) => entry.run.status === "running");
+	if (anyAgentRunning || anyRunRunning) return spinnerFrame("widget-header");
+	const slot = widgetRailSlot(runs);
+	if (slot === "error") return "✗";
+	if (slot === "success") return "✓";
+	return "";
+}
+
 // ── Header ────────────────────────────────────────────────────────────
 
-export function widgetHeader(runs: WidgetRun[], runningGlyph: string, maxLines = 20, notificationCount = 0): string {
+/**
+ * The dock's ONE row (RAIL §2.B):
+ *
+ *   `┃ ⠧ CREW ▸ fast-fix · 2 running · 3/5 done · ⏰ 1 sched ···· ↓·enter`
+ *
+ * Zero runs paint `┃ CREW ▸ idle · …` (see `idleWidgetLine`) instead. Returns
+ * PLAIN text — the component colorizes index 0 with `colorWidgetLine`.
+ */
+export function widgetHeader(
+	runs: WidgetRun[],
+	runningGlyph: string,
+	maxLines = 20,
+	notificationCount = 0,
+	schedSegment?: string,
+	maxWidth?: number,
+): string {
 	const agents = runs.flatMap((item) => item.agents);
-	const runningAgents = agents.filter((a) => a.status === "running").length;
-	const queuedAgents = agents.filter((a) => a.status === "queued").length;
-	const waitingAgents = agents.filter((a) => a.status === "waiting").length;
-	const completedAgents = agents.filter((a) => a.status === "completed").length;
-	const parts = [`${runningAgents} running`];
-	if (queuedAgents) parts.push(`${queuedAgents} queued`);
-	if (waitingAgents) parts.push(`${waitingAgents} waiting`);
-	if (completedAgents) parts.push(`${completedAgents}/${agents.length} done`);
-	return `${runningGlyph} Crew agents${notificationBadge(notificationCount)} · ${parts.join(" · ")} · /team-dashboard`;
+	const segments: string[] = [];
+	if (runs.length > 0) {
+		const runningAgents = agents.filter((a) => a.status === "running").length;
+		const queuedAgents = agents.filter((a) => a.status === "queued").length;
+		const waitingAgents = agents.filter((a) => a.status === "waiting").length;
+		const completedAgents = agents.filter((a) => a.status === "completed").length;
+		// Zero counts are noise on a one-line dock: a finished run reads
+		// `3/3 done`, not `0 running · 3/3 done`.
+		if (runningAgents) segments.push(`${runningAgents} running`);
+		if (queuedAgents) segments.push(`${queuedAgents} queued`);
+		if (waitingAgents) segments.push(`${waitingAgents} waiting`);
+		if (completedAgents) segments.push(`${completedAgents}/${agents.length} done`);
+		// WP-3 on the single line (2026-09-14 round 2): a run parked awaiting plan
+		// approval surfaces as a `⚠ plan:<run8>` segment — the row-level badge is
+		// gone with the run tree, so the count row carries the signal.
+		const planPending = runs.find((item) => isPlanApprovalStatePending(item.run.planApproval));
+		if (planPending) segments.push(`⚠ plan:${shortId(planPending.run.runId)}`);
+	}
+	// Tier C: `schedSegment` is the ALREADY-BUILT `⏰ …` string (jobs, hidden
+	// count and clock are all injected upstream — buildWidgetLines); undefined
+	// means nothing schedules-related paints.
+	if (schedSegment) segments.push(schedSegment);
+	// Bug 021: the alerts badge is one more segment (no 🔔, capped at 99+).
+	const badge = notificationBadge(notificationCount)
+		.replace(/^\s*·\s*/, "")
+		.trim();
+	if (badge) segments.push(badge);
+	const head = runningGlyph ? `${runningGlyph} ${dockIdentity(dockSubject(runs))}` : dockIdentity(dockSubject(runs));
+	const left = segments.length > 0 ? `${head} · ${segments.join(" · ")}` : head;
+	return dockLine(dockTail(left, PLAIN_THEME, maxWidth), PLAIN_THEME, "border");
 }
 
 // ── Agent ordering (shared with the inline panel) ──────────────────────
@@ -98,146 +229,114 @@ export function orderWidgetAgents(entry: WidgetRun, now = Date.now()): { active:
 
 // ── Line builder ──────────────────────────────────────────────────────
 
-/**
- * Row layout for the per-agent lines.
- *
- * - `detailed` — the historical two-line tree (name row + `⊶ activity` row).
- * - `compact`  — one width-budgeted line per agent, so a wide terminal shows the
- *   full description instead of the same clip a narrow one gets.
- */
-export type WidgetRowStyle = "compact" | "detailed";
-
 export interface WidgetRenderOptions {
-	rowStyle?: WidgetRowStyle;
 	/** Task id under the inline panel cursor, if any. */
 	selectedTaskId?: string;
 	/** Task id whose transcript pane is open, if any. */
 	viewedTaskId?: string;
 	/**
-	 * True while the inline panel holds the cursor. Every agent is then listed
-	 * (no MAX_AGENTS_DISPLAY cap) so keyboard navigation can reach all of them;
-	 * the idle widget stays capped to keep the prompt area small.
+	 * True while the inline panel holds the cursor. The inline panel then
+	 * gets a visible cursor acknowledgement; the idle widget stays compact
+	 * to keep the prompt area small.
 	 */
 	focused?: boolean;
+	/**
+	 * Injected clock (dialect D6-T4) for the Tier-C schedules line — pinned by
+	 * tests; defaults to "now" at the top of buildWidgetLines. The pure
+	 * schedules builder never reads the clock itself.
+	 */
+	now?: Date;
 }
 
-/** Short display form of a model id: `zai/glm-5.3` → `glm-5.3`. */
-function shortModelLabel(agent: CrewAgentRecord, run: TeamRunManifest): string | undefined {
-	const model = agent.model ?? run.modelContext?.parentModel ?? run.modelContext?.override;
-	if (typeof model !== "string" || !model) return undefined;
-	return model.split("/").at(-1) ?? model;
-}
+// ── Schedules line (Tier C) ───────────────────────────────────────────
 
-/** One flat dock row (pi-subtask style) for an agent — active or finished. */
-function compactAgentRow(
-	run: TeamRunManifest,
-	agent: CrewAgentRecord,
-	finished: boolean,
-	runs: readonly WidgetRun[],
-	options: WidgetRenderOptions,
-	width: number,
-	liveHandle: ReturnType<typeof listLiveAgents>[number] | undefined,
-): string {
-	const marker = options.selectedTaskId === agent.taskId ? "❯" : " ";
-	const dockGlyph = options.viewedTaskId === agent.taskId ? "⏺" : dockStatusIcon(agent.status);
-	const name = liveHandle?.agent ?? agent.agent;
-	const label = liveHandle?.description ?? agent.role ?? "";
-	// Task-first: the agent exists to run its task, so the row names the task
-	// right after the agent. With multiple runs, prefix each row with its run
-	// label so the flat dock still says which run an agent belongs to.
-	const runTag = runs.length > 1 ? `${shortRunLabel(run)} · ` : "";
-	const taskTag = agent.taskId ? ` · ${agent.taskId}` : "";
-	const roleTag = label && label !== agent.taskId && label !== name ? ` · ${label}` : "";
-	const nameText = runTag + name + taskTag + roleTag;
-	// pi-subtask activity: the worker's latest line while running, otherwise
-	// the status word.
-	const liveLine = liveHandle?.activity?.responseText
-		?.split("\n")
-		.find((line) => line.trim())
-		?.trim();
-	const activity =
-		!finished && liveHandle?.status === "running" && liveLine
-			? liveLine.length > 60
-				? `${liveLine.slice(0, 60)}…`
-				: liveLine
-			: finished
-				? dockStatusLabel(agent.status)
-				: agentActivity(agent, liveHandle);
-	const usage = dockUsageText(agent, liveHandle, { viewed: options.viewedTaskId === agent.taskId });
-	const ageText = dockElapsed(agent.completedAt ?? agent.startedAt);
-	const model = shortModelLabel(agent, run);
-	// Stats tail: `· glm-5.3 · ↑1.2k ↓350 · 41s` — the model the worker is
-	// actually on first, then usage, then elapsed.
-	const suffix = `${model ? ` · ${model}` : ""}${usage ? ` · ${usage}` : ""}${ageText ? ` · ${ageText}` : ""}`;
-	return budgetedRow({ lead: `${marker} ${dockGlyph} `, name: nameText, activity, suffix }, width);
+/**
+ * Tier C (schedules UI): the ONE low-priority schedules line for the crew
+ * widget — `⏰ N sched · next Xm`. Painted when ≥1 ENABLED job exists, always
+ * as the LAST row (below active-run info, per the widget priority rules),
+ * with an optional compact `· N hidden` segment (P2-1) when the B2 gate is
+ * hiding project-tier jobs. Pure (dialect D6-T4): jobs, the clock, AND the
+ * hidden count are injected — no Date.now()/settings read happens here.
+ * Returns undefined when the line must not paint (0 enabled jobs AND nothing
+ * hidden), so callers skip the row entirely. With ZERO enabled jobs but a
+ * hidden count > 0, the hidden-only line still paints — that is exactly the
+ * all-gated case where an invisible gate used to show nothing at all.
+ */
+export function buildSchedulesWidgetLine(jobs: readonly ScheduledJob[], now: Date, hiddenCount = 0): string | undefined {
+	const enabled = jobs.filter((job) => job.enabled);
+	const hidden = hiddenCount > 0 ? ` · ${hiddenCount} hidden` : "";
+	if (enabled.length === 0) return hiddenCount > 0 ? `⏰ 0 sched${hidden}` : undefined;
+	const nextTargets = enabled
+		// new Date(iso) here is a STORED-ISO parse, not a clock read.
+		.map((job) => (job.nextRun ? new Date(job.nextRun).getTime() : Number.NaN))
+		.filter((ms) => Number.isFinite(ms));
+	if (nextTargets.length === 0) return `⏰ ${enabled.length} sched${hidden}`;
+	const next = Math.min(...nextTargets);
+	// "in 84m" → "next 84m": the future prefix is redundant right after
+	// "next"; overdue targets keep their "Xm ago" tail so a stale nextRun
+	// stays legible instead of silently reading as future work.
+	const relative = formatRelativeTime(now, new Date(next)).replace(/^in /, "");
+	return `⏰ ${enabled.length} sched · next ${relative}${hidden}`;
 }
 
 /**
- * The compact dock: hint line, the `main` conversation row, then a
- * MAX_AGENTS_DISPLAY-row SCROLL WINDOW over the flat agent list (exactly the
- * order the inline panel navigates — `panelRowsFromRuns` parity). The window
- * follows the panel selection bottom-pinned: moving the cursor past the
- * window scrolls one row at a time and the ❯ marker is always painted; idle
- * (no selection) shows the top of the list, which the shared ordering puts at
- * the highest-priority live agents. Hidden rows surface as `… ↑N earlier` /
- * `… +N more` indicators.
+ * Injectable scheduled-jobs reader for the widget (single source of truth,
+ * G17): the default reads through getScheduledJobs(); tests swap in a stub
+ * so the render path never touches real scheduler/settings state.
+ *
+ * The default is gated on a REGISTERED scheduler: without one (unit tests,
+ * pre-registration, post-cleanup) there are no armed jobs to report — and we
+ * must never hit the settings store from a paint path (P0-6: no disk per
+ * render tick).
  */
-function compactDockLines(
-	runs: WidgetRun[],
-	options: WidgetRenderOptions,
-	width: number,
-	maxLines: number,
-	notificationCount: number,
-	runningGlyph: string,
-): string[] {
-	const now = Date.now();
-	const flat: Array<{
-		run: TeamRunManifest;
-		agent: CrewAgentRecord;
-		finished: boolean;
-		liveHandle: ReturnType<typeof listLiveAgents>[number] | undefined;
-	}> = [];
-	for (const entry of runs) {
-		const { active, finished } = orderWidgetAgents(entry, now);
-		const liveForRun = listLiveAgents().filter((a) => a.runId === entry.run.runId);
-		for (const agent of active) {
-			flat.push({ run: entry.run, agent, finished: false, liveHandle: liveForRun.find((h) => h.taskId === agent.taskId) });
-		}
-		for (const agent of finished) {
-			flat.push({ run: entry.run, agent, finished: true, liveHandle: liveForRun.find((h) => h.taskId === agent.taskId) });
-		}
+export type WidgetScheduledJobsReader = (cwd: string) => ScheduledJob[];
+let scheduledJobsReader: WidgetScheduledJobsReader = defaultScheduledJobsReader;
+
+function defaultScheduledJobsReader(cwd: string): ScheduledJob[] {
+	if (!getCrewScheduler()) return [];
+	try {
+		return getScheduledJobs(cwd);
+	} catch {
+		return [];
 	}
+}
 
-	// No agents at all: fall back to the legacy header so the space under the
-	// editor is never just blank.
-	if (flat.length === 0) return [widgetHeader(runs, runningGlyph, maxLines, notificationCount)];
-
-	const lines: string[] = [];
-	let hint: string;
-	if (options.viewedTaskId) {
-		const viewedName = flat.find((row) => row.agent.taskId === options.viewedTaskId)?.agent.agent ?? "agent";
-		hint = `viewing @${viewedName} — typing goes to the agent · ↓ switch · esc back`;
-	} else if (options.focused) {
-		hint = "enter to view · x to stop/cancel · esc back";
-	} else {
-		hint = `agents (${flat.length}) — ↓ to select`;
-	}
-	lines.push(truncate(hint, width));
-	// Filled ● = you're on the main conversation; hollow ◯ = an agent view is
-	// open (same convention as pi-subtask's main row).
-	const mainMarker = options.focused && !options.selectedTaskId ? "❯" : " ";
-	const mainIcon = options.viewedTaskId ? "◯" : "●";
-	lines.push(truncate(`${mainMarker} ${mainIcon} main`, width));
-
-	const selectedIndex = options.selectedTaskId ? flat.findIndex((row) => row.agent.taskId === options.selectedTaskId) : -1;
-	const windowStart = selectedIndex >= 0 ? Math.max(0, selectedIndex - MAX_AGENTS_DISPLAY + 1) : 0;
-	const windowEnd = Math.min(flat.length, windowStart + MAX_AGENTS_DISPLAY);
-	if (windowStart > 0) lines.push(truncate(`  … ↑${windowStart} earlier (↑ to scroll)`, width));
-	for (const row of flat.slice(windowStart, windowEnd)) {
-		lines.push(compactAgentRow(row.run, row.agent, row.finished, runs, options, width, row.liveHandle));
-	}
-	if (windowEnd < flat.length) lines.push(truncate(`  … +${flat.length - windowEnd} more (↓ to scroll)`, width));
-	return lines;
+/** @internal — test seam: inject a deterministic jobs view. */
+export function setWidgetScheduledJobsReader(reader: WidgetScheduledJobsReader): void {
+	scheduledJobsReader = reader;
+}
+
+/** @internal — test seam: restore the provider-backed default. */
+export function resetWidgetScheduledJobsReader(): void {
+	scheduledJobsReader = defaultScheduledJobsReader;
+}
+
+/** Injectable hidden-jobs reader (P2-1) — mirrors the jobs reader seam: the
+ * default is gated on the REGISTERED scheduler exactly like
+ * defaultScheduledJobsReader (P0-6 — a paint path must never hit the settings
+ * store), and with a registered scheduler it only ever serves the in-memory
+ * registration-time stash from handle-schedule.ts. */
+export type WidgetHiddenJobsReader = (cwd: string) => number;
+let hiddenJobsReader: WidgetHiddenJobsReader = defaultHiddenJobsReader;
+
+function defaultHiddenJobsReader(_cwd: string): number {
+	if (!getCrewScheduler()) return 0;
+	return getScheduledJobsHiddenCountView(); // stash-only when registered: no disk
+}
+
+/** @internal — test seam: inject a deterministic hidden count. */
+export function setWidgetHiddenJobsReader(reader: WidgetHiddenJobsReader): void {
+	hiddenJobsReader = reader;
+}
+
+/** @internal — test seam: restore the stash-backed default. */
+export function resetWidgetHiddenJobsReader(): void {
+	hiddenJobsReader = defaultHiddenJobsReader;
+}
+
+/** Reader-backed schedules line — the widget's live data path. */
+export function schedulesWidgetLine(cwd: string, now: Date): string | undefined {
+	return buildSchedulesWidgetLine(scheduledJobsReader(cwd), now, hiddenJobsReader(cwd));
 }
 
 export function buildWidgetLines(
@@ -249,133 +348,67 @@ export function buildWidgetLines(
 	width = DEFAULT_WIDGET_WIDTH,
 	options: WidgetRenderOptions = {},
 ): string[] {
-	const rowStyle: WidgetRowStyle = options.rowStyle ?? "detailed";
-	const focused = options.focused === true;
-	// Match the legacy `buildCrewWidgetLines` API: when no runs are supplied,
-	// auto-fetch via activeWidgetRuns(cwd). Otherwise widgets calling with
-	// only `(cwd, frame)` would render an empty line set (regression vs. the
-	// pre-refactor implementation that called activeWidgetRuns here).
+	// SINGLE-LINE DOCK (design system §2.B, maintainer design 2026-09-14): the
+	// dock paints EXACTLY ONE row — `┃ <identity> · counts · schedules ····
+	// ↓·enter`. No per-agent rows, no run tree, no scroll window; ALL browsing
+	// lives in the Agents & Jobs browser, opened by ↓·enter from THIS line
+	// (crew-editor: idle enter at the line target = browser). The rail glyph is
+	// always `┃` — `┏`/`┗` would imply a multi-line card.
+	//
+	// Focused (the ↓ cursor sits ON this line): prefix a ❯ marker so the
+	// keystroke is visibly acknowledged — the line itself is the cursor target;
+	// there is no second row to land on. maxLines/frame remain in the signature
+	// for call-site compatibility; a single line is always within budget.
+	const schedLine = schedulesWidgetLine(cwd, options.now ?? new Date());
 	const runs = providedRuns ?? activeWidgetRuns(cwd);
-	if (!runs.length) return [];
-
-	const runningGlyph = spinnerFrame("widget-header");
-
-	// Compact = pi-subtask's dock: NO "Crew agents" header, NO tree — hint
-	// line, `main` row, then a 3-row scroll window over the flat agent list.
-	if (rowStyle === "compact") {
-		const lines = compactDockLines(runs, options, width, maxLines, notificationCount, runningGlyph);
-		return focused ? lines : lines.slice(0, maxLines);
-	}
-
-	const lines: string[] = [widgetHeader(runs, runningGlyph, maxLines, notificationCount)];
-
-	for (const entry of runs) {
-		const { run, agents } = entry;
-		const now = Date.now();
-		const { active: activeAgents, finished: finishedAgents } = orderWidgetAgents(entry, now);
-		const completed = agents.filter((a) => a.status === "completed").length;
-		// WP-3 (H4): while a run is parked awaiting plan approval, the spinner
-		// glyph is replaced by a `⚠ plan:<last-8 runId>` badge. Plain-unicode ⚠
-		// (the same glyph needs_attention already uses) stays legible in no-color
-		// mode and is colorized by the shared colorizeStatusGlyphs pass. In-place
-		// glyph swap only — no extra line, so the MAX_AGENTS_DISPLAY / maxLines
-		// budget and the truncate(width) rule are untouched.
-		const planPending = isPlanApprovalStatePending(run.planApproval);
-		const runGlyph = planPending ? `⚠ plan:${run.runId.slice(-8)}` : iconForStatus(run.status, { runningGlyph });
-		const isTerminal = isFinishedRunStatus(run.status);
-		// Run progress line. v1–v3 flickered on snapshot.tasks state, v4 was
-		// too minimal (`0/1 agents` only), v5 duplicated the worker activity
-		// line (tools/tokens/duration already shown one row below). v6 (this)
-		// shows only data that is RUN-level (not already in the per-agent
-		// activity line) and is GUARANTEED stable across ticks:
-		//   - agents count — from `agents` array, always populated, never empty.
-		//   - run elapsed   — from `run.createdAt`, always set on manifest.
-		//
-		// Bug 022 (timer-fix + label): for TERMINAL runs (failed/cancelled/
-		// completed) the elapsed counter previously kept ticking up forever
-		// from createdAt (a failed run showed `2028s` and climbing, read as
-		// "still running"). Now it FREEZES at updatedAt (when the run
-		// reached its terminal status). The status label is also surfaced
-		// explicitly so the row cannot be misread as an active run.
-		const agentCountText = `${completed}/${agents.length} agents`;
-		const runEndMs = isTerminal ? new Date(run.updatedAt).getTime() : now;
-		const runElapsedMs = Math.max(0, Number.isFinite(runEndMs) ? runEndMs - new Date(run.createdAt).getTime() : 0);
-		const runElapsedText = `${Math.floor(runElapsedMs / 1000)}s`;
-		const statusLabel = isTerminal ? ` · ${run.status}` : "";
-		const progressPart = `${agentCountText} · ${runElapsedText}${statusLabel}`;
-		lines.push(truncate(`├─ ${runGlyph} ${shortRunLabel(run)} · ${progressPart} · ${run.runId.slice(-8)}`, width));
-
-		const liveForRun = listLiveAgents().filter((a) => a.runId === run.runId);
-
-		// Focused: list every agent so the keyboard cursor can reach it. Idle: keep
-		// the historical cap so the prompt area stays small.
-		const activeCap = focused ? activeAgents.length : MAX_AGENTS_DISPLAY;
-		// Finished rows only appear in slots not used by active agents (max 2). When
-		// there are >= MAX_AGENTS_DISPLAY live workers, finished rows are suppressed
-		// entirely so they cannot push a live agent's activity line off-screen.
-		const finishedSlots = focused ? finishedAgents.length : Math.max(0, Math.min(2, MAX_AGENTS_DISPLAY - activeAgents.length));
-
-		/** Cursor marker column, mirroring the inline panel's selection. */
-		const markerFor = (taskId: string): string => (options.selectedTaskId === taskId ? "❯" : " ");
-
-		const visibleAgents = activeAgents.slice(0, activeCap);
-		for (const [index, agent] of visibleAgents.entries()) {
-			const last = index === visibleAgents.length - 1 && activeAgents.length <= activeCap && finishedSlots === 0;
-			const branch = last ? "└─" : "├─";
-			const liveHandle = liveForRun.find((h) => h.taskId === agent.taskId);
-			const legacyGlyph = options.viewedTaskId === agent.taskId ? "◉" : iconForStatus(agent.status, { runningGlyph });
-			const stats = agentStats(agent, liveHandle);
-			const name = liveHandle?.agent ?? agent.agent;
-			const activity = agentActivity(agent, liveHandle);
-			const desc = truncate(liveHandle?.description ?? agent.role ?? "", TASK_DESC_MAX);
-			const _activeMain = truncate(`│  ${branch} ${legacyGlyph} ${name}${desc ? ` · ${desc}` : ` · ${agent.role}`}`, width);
-			lines.push(_activeMain);
-			const _activity = truncate(`│     ⊶ ${activity}${stats ? ` · ${stats}` : ""}`, width);
-			lines.push(_activity);
-		}
-
-		if (activeAgents.length > activeCap) {
-			lines.push(truncate(`│  └─ … +${activeAgents.length - activeCap} more agents`, width));
-		}
-
-		for (const [index, agent] of finishedAgents.slice(0, finishedSlots).entries()) {
-			const liveHandle = liveForRun.find((h) => h.taskId === agent.taskId);
-			const name = liveHandle?.agent ?? agent.agent;
-			const legacyIcon =
-				agent.status === "completed" ? "✓" : agent.status === "failed" ? "✗" : agent.status === "needs_attention" ? "⚠" : "▪";
-			const stats = agentStats(agent, liveHandle);
-			const desc = truncate(liveHandle?.description ?? agent.role ?? "", TASK_DESC_MAX);
-			const isLastFinished = index === Math.min(finishedAgents.length, finishedSlots) - 1;
-			const branch = isLastFinished ? "└─" : "├─";
-			const _finished = truncate(`│  ${branch} ${legacyIcon} ${name} · ${desc}${stats ? ` · ${stats}` : ""}`, width);
-			lines.push(_finished);
-		}
-
-		// Focused (inline panel cursor active): the keyboard can reach every
-		// agent, so the renderer must list them ALL — clipping here would put
-		// the cursor marker (❯) on rows that are never painted. The idle
-		// widget keeps its historical cap to hold the prompt area small.
-		if (lines.length >= maxLines && !focused) break;
+	const focused = options.focused === true;
+	if (!runs.length) {
+		// Zero runs keep-alive (Tier C): jobs are exactly what run while no
+		// interactive run is active. The ⏰ segment stands alone as the row; with
+		// no schedules either there is NOTHING to paint — `[]`, never a bare
+		// hint and never the literal `undefined — ↓·enter` (live bug 2026-09-16).
+		const idle = idleWidgetLine(schedLine, focused);
+		return idle ? [truncate(idle, width)] : [];
 	}
-
-	return focused ? lines : lines.slice(0, maxLines);
+	const base = widgetHeader(runs, widgetActivityGlyph(runs), maxLines, notificationCount, schedLine, width);
+	return [truncate(focused ? `${FOCUS_MARKER} ${base}` : base, width)];
 }
 
 // ── Colorization ──────────────────────────────────────────────────────
 
-export function colorWidgetLine(line: string, index: number, theme: CrewTheme): string {
+/**
+ * Paint pass for a PLAIN dock/plan line (`index 0` = the identity row).
+ *
+ * The builders above return plain text, so this adds the identity/rail/chrome
+ * colours: the leading `┃` (or plan `┏`) takes the rail slot — `statusSlot` of
+ * the aggregate run status, injected by the component — the identity word goes
+ * accent+bold, and the tail hint is dimmed. Lines that were ALREADY built with
+ * a real theme (the task-list variant builds through `rail.ts` directly) carry
+ * escapes and are passed through untouched, apart from the shared glyph
+ * colorizer below.
+ */
+export function colorWidgetLine(line: string, index: number, theme: CrewTheme, slot: RailSlot = "border"): string {
 	let result = line;
-	if (index === 0) {
-		result = result.replace("Crew agents", theme.bold(theme.fg("accent", "Crew agents")));
+	if (index === 0 && !result.includes("\u001b")) {
+		// `┏|┃ <WORD> ▸ <subject>`: rail glyph takes the state slot, the identity
+		// word accent+bold, the subject toolTitle+bold. The subject is bounded by
+		// the first ` ·` so a count segment can never be swallowed.
+		result = result.replace(
+			/^([❯] )?([┃┏]) (?:(\S+) )?((?:CREW|PLAN)(?: ▸ [^·]+?)?)(?= ·|$)/,
+			(_match, cursor: string | undefined, glyph: string, spinner: string | undefined, identity: string) => {
+				const [word = "", subject] = identity.split(" ▸ ");
+				const tail = subject ? ` ${theme.fg("dim", ACTIVE)} ${theme.fg("toolTitle", theme.bold(subject))}` : "";
+				// The spinner is re-emitted raw: the shared glyph colorizer below
+				// paints the braille range accent.
+				return `${cursor ?? ""}${theme.fg(slot, glyph)} ${spinner ? `${spinner} ` : ""}${theme.fg("accent", theme.bold(word))}${tail}`;
+			},
+		);
+		result = result.replace(DOCK_HINT, theme.fg("dim", DOCK_HINT));
 	}
 	// Shared glyph colorizer covers ALL status glyphs — including ⏳ (waiting),
 	// ⚠ (needs_attention), and the braille spinner range ⠁-⣿ (running) — which the
 	// previous local statusGlyphColor map + regex omitted (F-1, V-3).
-	result = colorizeStatusGlyphs(result, theme);
-	if (index === 0) {
-		result = theme.fg("accent", result);
-	}
-	return result;
+	return colorizeStatusGlyphs(result, theme);
 }
 
 export function renderLines(lines: string[], width: number): string[] {