pi-plans 0.6.0 → 0.7.0

package/src/config-command.ts

@@ -1,5 +1,16 @@
 import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_CONFIG, readActive, resolveStateRootOrNull, showConfig, type PlansConfig, utcNow, VALID_ROLE_MODES, updateConfig } from "./state.ts";
+import {
+	readActive,
+	showStateView,
+	setRole,
+	type PlansConfig,
+	utcNow,
+	VALID_ROLE_MODES,
+	updateConfig,
+	type GlobalRoleConfig,
+} from "./state.ts";
+import { DEFAULT_LEVEL_SENTINEL } from "./thinking-levels.ts";
+import { effortItems, runFirstUseFlow, type RolePanelHost } from "./role-panels.ts";
 import { refreshUiLanguage } from "./exec.ts";
 
 interface ModelLike {
@@ -10,12 +21,15 @@ interface ModelLike {
 export interface ConfigCommandContext {
 	cwd: string;
 	hasUI: boolean;
+	mode?: string;
 	model?: unknown;
 	scopedModels?: Array<{ model?: unknown }>;
 	modelRegistry?: {
 		getAvailable?: () => unknown[];
+		find?: (provider: string, id: string) => unknown;
 	};
-	ui: Pick<ExtensionContext["ui"], "notify" | "select" | "input">;
+	ui: Pick<ExtensionContext["ui"], "notify" | "select" | "input"> &
+		Partial<Pick<ExtensionContext["ui"], "custom">>;
 }
 
 type ChoiceResult<T> =
@@ -142,7 +156,7 @@ async function promptLanguage(ctx: ConfigCommandContext, current: string | null)
 
 async function promptArtifactRoot(ctx: ConfigCommandContext, current: string): Promise<ChoiceResult<string>> {
 	const options: Array<MenuOption<string>> = [{ label: `Keep current (${current})`, value: current }];
-	for (const root of ["./docs/pi-plans", "./.git/pi_plans/plans"]) {
+	for (const root of ["./.git/pi-plans/plans", "./docs/pi-plans"]) {
 		if (root === current) continue;
 		options.push({ label: root, value: root });
 	}
@@ -188,7 +202,7 @@ async function promptGraphEnabled(ctx: ConfigCommandContext, current: boolean |
 	return promptMenu(ctx, "Code graph?", options);
 }
 
-async function promptRoleMode(ctx: ConfigCommandContext, role: "reviewer" | "criticizer", current: string): Promise<ChoiceResult<string>> {
+async function promptRoleMode(ctx: ConfigCommandContext, current: string): Promise<ChoiceResult<string>> {
 	if (!VALID_ROLE_MODES.has(current)) {
 		current = "delegated-subagent";
 	}
@@ -202,56 +216,115 @@ async function promptRoleMode(ctx: ConfigCommandContext, role: "reviewer" | "cri
 				{ label: "Keep current-session", value: "current-session" },
 				{ label: "Switch to delegated-subagent", value: "delegated-subagent" },
 			];
-	return promptMenu(ctx, `${role[0].toUpperCase()}${role.slice(1)} mode?`, options);
+	return promptMenu(ctx, "Reviewer mode?", options);
 }
 
-async function promptRoleModel(
+async function promptRoleModelEntry(
 	ctx: ConfigCommandContext,
-	role: "reviewer" | "criticizer",
-	currentSelector: string | null,
-): Promise<ChoiceResult<string | null>> {
-	const currentLiveSelector = modelSelectorOf(ctx.model);
-	const options: Array<MenuOption<string | null>> = [
-		{
-			label: currentSelector
-				? `Keep current default (${currentSelector})`
-				: currentLiveSelector
-					? `Keep current default (inherit live model: ${currentLiveSelector})`
-					: "Keep current default (inherit)",
-			value: currentSelector,
-		},
+	role: GlobalRoleConfig,
+): Promise<ChoiceResult<"keep" | "change">> {
+	const level = role.thinking_level ?? DEFAULT_LEVEL_SENTINEL;
+	const keepLabel =
+		role.model_selector !== null && role.confirmed_at !== null
+			? `Keep current (${role.model_selector} · ${level})`
+			: "Keep current (unconfirmed; first refine will ask)";
+	const options: Array<MenuOption<"keep" | "change">> = [
+		{ label: keepLabel, value: "keep" },
+		{ label: "Choose model & thinking level…", value: "change" },
 	];
-	if (currentLiveSelector && currentLiveSelector !== currentSelector) {
-		options.push({ label: `Use current session model (${currentLiveSelector})`, value: currentLiveSelector });
+	return promptMenu(ctx, "Reviewer model?", options);
+}
+
+/** Change flow (Q-3=A): TUI pops the native panels via runFirstUseFlow
+ * (which persists to the global config on completion); other UI modes use
+ * menus (model list → effort list). Esc anywhere keeps the current role —
+ * the wizard continues instead of discarding earlier answers (F-011). */
+async function changeReviewerRole(
+	ctx: ConfigCommandContext,
+	role: GlobalRoleConfig,
+): Promise<{ role: GlobalRoleConfig; changed: boolean; error?: string }> {
+	const host = ctx as unknown as RolePanelHost;
+	if (ctx.mode === "tui" && typeof ctx.ui.custom === "function") {
+		const outcome = await runFirstUseFlow(host, role.thinking_level);
+		if (outcome.status === "confirmed") return { role: outcome.role, changed: true };
+		if (outcome.status === "cancelled") {
+			ctx.ui.notify("Reviewer change cancelled — keeping the current role.", "warning");
+			return { role, changed: false };
+		}
+		return { role, changed: false, error: "native panels unavailable in this session" };
 	}
+	// Menus: model list (live model first, then scoped/registry), then effort.
+	const currentSelector = role.model_selector;
+	const selectors: string[] = [];
+	const live = modelSelectorOf(ctx.model);
+	if (live) selectors.push(live);
 	for (const selector of collectModelSelectors(ctx, currentSelector)) {
-		if (selector === currentLiveSelector) continue;
-		options.push({ label: `Use available model (${selector})`, value: selector });
+		if (selector === live) continue;
+		selectors.push(selector);
 	}
-	options.push({
-		label: "Other...",
-		parse: parseModelSelector,
-		prompt: `${role[0].toUpperCase()}${role.slice(1)} model selector:`,
-		errorMessage: "Model selector must be an exact provider/model string.",
-	});
-	return promptMenu(ctx, `${role[0].toUpperCase()}${role.slice(1)} model?`, options);
+	const modelLabels = [...selectors.map((selector) => `Use ${selector}`), "Other..."];
+	const picked = await ctx.ui.select("Reviewer model?", modelLabels);
+	if (picked === undefined) {
+		ctx.ui.notify("Reviewer change cancelled — keeping the current role.", "warning");
+		return { role, changed: false };
+	}
+	let selector: string | null = null;
+	if (picked === "Other...") {
+		const raw = await ctx.ui.input("Reviewer model selector:");
+		if (raw === undefined) {
+			ctx.ui.notify("Reviewer change cancelled — keeping the current role.", "warning");
+			return { role, changed: false };
+		}
+		selector = parseModelSelector(raw);
+		if (selector === null) {
+			ctx.ui.notify("Model selector must be an exact provider/model string.", "error");
+			return { role, changed: false, error: "invalid model selector" };
+		}
+	} else {
+		selector = picked.replace(/^Use /, "");
+	}
+	// Effort menu: default sentinel + the chosen model's supported levels.
+	const found =
+		typeof ctx.modelRegistry?.find === "function"
+			? ((ctx.modelRegistry.find(selector.split("/")[0]!, selector.split("/")[1]!) as never) ?? null)
+			: null;
+	const items = found ? effortItems(found, role.thinking_level) : [{ value: DEFAULT_LEVEL_SENTINEL, label: DEFAULT_LEVEL_SENTINEL, description: "no --thinking flag" }];
+	const levelLabels = items.map((item) => `${item.label} — ${item.description}`);
+	const levelPicked = await ctx.ui.select("Reviewer thinking level? (first row = default: no --thinking flag)", levelLabels);
+	const levelValue = levelPicked === undefined ? DEFAULT_LEVEL_SENTINEL : items[levelLabels.indexOf(levelPicked)]?.value ?? DEFAULT_LEVEL_SENTINEL;
+	try {
+		const applied = setRole(ctx.cwd, {
+			role: "reviewer",
+			modelSelector: selector,
+			thinkingLevel: levelValue,
+			confirmed: true,
+		});
+		return { role: applied.global.reviewer, changed: true };
+	} catch (error) {
+		return { role, changed: false, error: (error as Error).message };
+	}
+}
+
+interface WizardCurrent {
+	config: PlansConfig;
+	reviewer: GlobalRoleConfig;
 }
 
-function currentConfig(workdir: string): PlansConfig {
-	const stateRoot = resolveStateRootOrNull(workdir);
-	if (!stateRoot) return structuredClone(DEFAULT_CONFIG);
-	return showConfig(workdir);
+function currentConfig(workdir: string): WizardCurrent {
+	const view = showStateView(workdir);
+	return { config: view.config, reviewer: view.reviewer };
 }
 
-function summarizeConfig(config: PlansConfig): string[] {
+function summarizeConfig(config: PlansConfig, reviewer: GlobalRoleConfig): string[] {
+	const level = reviewer.thinking_level ?? DEFAULT_LEVEL_SENTINEL;
+	const model = reviewer.model_selector ?? (reviewer.mode === "current-session" ? "(in-session)" : "(unconfirmed)");
 	return [
 		"pi-plans config updated.",
 		`Language: ${config.language.tag ?? "(unset)"}`,
 		`Artifact root: ${config.artifact_root}`,
 		`Refs root: ${config.refs_root ?? "(unset)"}`,
 		`Code graph: ${config.graph_enabled === true ? "enabled" : config.graph_enabled === false ? "disabled" : "unset"}`,
-		`Reviewer: ${config.reviewer.mode} / ${config.reviewer.model_selector ?? "inherit"}`,
-		`Criticizer: ${config.criticizer.mode} / ${config.criticizer.model_selector ?? "inherit"}`,
+		`Reviewer (global): ${reviewer.mode} / ${model}${reviewer.mode === "current-session" ? "" : ` · ${level}`}`,
 	];
 }
 
@@ -264,8 +337,10 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 	try {
 		const workdir = ctx.cwd;
 		const current = currentConfig(workdir);
+		let reviewer = current.reviewer;
+		const workspace = current.config;
 
-		const language = await promptLanguage(ctx, current.language.tag);
+		const language = await promptLanguage(ctx, workspace.language.tag);
 		if (language.cancelled) {
 			if (language.reason === "user") {
 				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
@@ -273,7 +348,7 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 			return;
 		}
 
-		const artifactRoot = await promptArtifactRoot(ctx, current.artifact_root);
+		const artifactRoot = await promptArtifactRoot(ctx, workspace.artifact_root);
 		if (artifactRoot.cancelled) {
 			if (artifactRoot.reason === "user") {
 				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
@@ -281,7 +356,7 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 			return;
 		}
 
-		const refsRoot = await promptRefsRoot(ctx, current.refs_root);
+		const refsRoot = await promptRefsRoot(ctx, workspace.refs_root);
 		if (refsRoot.cancelled) {
 			if (refsRoot.reason === "user") {
 				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
@@ -289,7 +364,7 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 			return;
 		}
 
-		const graphEnabled = await promptGraphEnabled(ctx, current.graph_enabled);
+		const graphEnabled = await promptGraphEnabled(ctx, workspace.graph_enabled);
 		if (graphEnabled.cancelled) {
 			if (graphEnabled.reason === "user") {
 				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
@@ -297,36 +372,40 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 			return;
 		}
 
-		const reviewerMode = await promptRoleMode(ctx, "reviewer", current.reviewer.mode);
+		const reviewerMode = await promptRoleMode(ctx, reviewer.mode);
 		if (reviewerMode.cancelled) {
 			if (reviewerMode.reason === "user") {
 				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
 			}
 			return;
 		}
-
-		const reviewerModel = await promptRoleModel(ctx, "reviewer", current.reviewer.model_selector);
-		if (reviewerModel.cancelled) {
-			if (reviewerModel.reason === "user") {
-				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
+		if (reviewerMode.value !== reviewer.mode) {
+			// Mode lives in the global role: persist the switch immediately;
+			// the model/thinking level stays untouched.
+			try {
+				const applied = setRole(workdir, { role: "reviewer", mode: reviewerMode.value });
+				reviewer = applied.global.reviewer;
+			} catch (error) {
+				ctx.ui.notify(`Failed to switch the reviewer mode: ${(error as Error).message}`, "error");
 			}
-			return;
 		}
 
-		const criticizerMode = await promptRoleMode(ctx, "criticizer", current.criticizer.mode);
-		if (criticizerMode.cancelled) {
-			if (criticizerMode.reason === "user") {
-				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
+		// Q-3=A: current-session never uses a spawned model — skip the model
+		// step entirely (and never clear an existing selector).
+		let reviewerError: string | undefined;
+		if (reviewer.mode === "delegated-subagent") {
+			const entry = await promptRoleModelEntry(ctx, reviewer);
+			if (entry.cancelled) {
+				if (entry.reason === "user") {
+					ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
+				}
+				return;
 			}
-			return;
-		}
-
-		const criticizerModel = await promptRoleModel(ctx, "criticizer", current.criticizer.model_selector);
-		if (criticizerModel.cancelled) {
-			if (criticizerModel.reason === "user") {
-				ctx.ui.notify("Configuration wizard cancelled. No changes were written.", "warning");
+			if (entry.value === "change") {
+				const changed = await changeReviewerRole(ctx, reviewer);
+				reviewer = changed.role;
+				reviewerError = changed.error;
 			}
-			return;
 		}
 
 		const updated = updateConfig(workdir, (config) => {
@@ -340,18 +419,9 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 			config.refs_root_updated_at = now;
 			config.graph_enabled = graphEnabled.value;
 			config.graph_enabled_updated_at = now;
-			config.reviewer = {
-				...config.reviewer,
-				mode: reviewerMode.value,
-				model_selector: reviewerModel.value,
-				confirmed_at: now,
-			};
-			config.criticizer = {
-				...config.criticizer,
-				mode: criticizerMode.value,
-				model_selector: criticizerModel.value,
-				confirmed_at: now,
-			};
+			// The reviewer role lives in the GLOBAL config since v0.7.0 — the
+			// wizard only strips a legacy workspace key, never writes one.
+			delete config.reviewer;
 			return config;
 		});
 
@@ -362,7 +432,10 @@ export async function configPiPlansCommand(_args: string, ctx: ConfigCommandCont
 		// Display-only consumer (F-006): deliberately keeps the shared active
 		// pointer — the wizard summarizes repo state, not session attribution.
 		const active = readActive(workdir);
-		const lines = summarizeConfig(updated.config);
+		const lines = summarizeConfig(updated.config, reviewer);
+		if (reviewerError) {
+			lines.push(`Reviewer change failed (${reviewerError}); the reviewer role is unchanged. Workspace settings above were still written.`);
+		}
 		if (active) {
 			lines.push(`Active run left unchanged: ${active.run_id}`);
 		}

package/src/dashboard.ts

@@ -0,0 +1,257 @@
+/**
+ * Task dashboard (v0.6.1): the execution-phase UI. A compact aboveEditor
+ * widget shows the current task, wave, progress bar, and verification-check
+ * state; Ctrl+Shift+T toggles an expanded tree view with per-task markers
+ * (✓ complete, ▸ current, ~ skipped, · pending). Pure model + render
+ * functions shared by the widget, the status line, and the expanded view so
+ * all three never disagree. Width-adaptive: narrow terminals get compact
+ * rows, wide terminals get full titles and file lists.
+ *
+ * Hard invariant: every returned line is at most `width` *display columns*.
+ * The widget host measures each line with its own `visibleWidth` and throws an
+ * uncaughtException (killing the whole TUI session) when a line is wider than
+ * the terminal, so all width math here is column-based via the shared helpers
+ * — never `.length`, `padEnd`, or `slice`, which count UTF-16 units and
+ * undercount CJK (one CJK char = one unit but two columns).
+ */
+
+import type { CheckItem } from "./plan.ts";
+import { truncateToWidth, visibleWidth } from "./refine-ui-helpers.ts";
+import {
+	allTasksTerminal,
+	currentTask,
+	flattenTaskViews,
+	maxWave,
+	taskIsTerminal,
+	taskProgress,
+	type TaskView,
+} from "./tasks.ts";
+
+export const DASHBOARD_WIDGET_KEY = "pi-plans-dashboard";
+
+export interface DashboardModel {
+	topic: string;
+	tasks: TaskView[];
+	checklist: CheckItem[];
+	paused: boolean;
+	pausedReason?: string;
+	/** Audit round counter; null = audit not yet started. */
+	auditRounds: number | null;
+	auditFailed: string[];
+	startedAt: string;
+	usage: { inToks: number; outToks: number };
+}
+
+/** Tree marker for one task row. */
+export function taskMarker(task: TaskView, currentId: string | null): string {
+	if (taskIsTerminal(task)) return task.status === "skipped" ? "~" : "✓";
+	if (task.id === currentId) return "▸";
+	return "·";
+}
+
+/** Truncate to at most `max` display columns, ellipsis when clipped. */
+function clip(text: string, max: number): string {
+	return max <= 0 ? "" : truncateToWidth(text, max);
+}
+
+/** Pad with `fill` out to exactly `width` display columns; never widens. */
+function padToWidth(text: string, width: number, fill = " "): string {
+	const gap = width - visibleWidth(text);
+	return gap > 0 ? text + fill.repeat(gap) : text;
+}
+
+/**
+ * One bordered row of exactly `width` display columns: left border, fitted
+ * body, filler, right border. Every compact row goes through here so the box
+ * can never be `width + 1` columns wide (the old `padEnd().slice(0, width) +
+ * border` shape was one column over on every row).
+ */
+function boxRow(left: string, body: string, fill: string, width: number, right = left): string {
+	const inner = Math.max(0, width - 2);
+	return left + padToWidth(clip(body, inner), inner, fill) + right;
+}
+
+/** Last-resort clamp so no rendered line can ever exceed the terminal width. */
+function clampLines(lines: string[], width: number): string[] {
+	if (width <= 0) return [];
+	return lines.map((line) => truncateToWidth(line, width));
+}
+
+/** Minimal structural subset of the pi Theme the widget needs. */
+export interface DashboardTheme {
+	fg(color: string, text: string): string;
+}
+
+/** Brand label opening the title row. */
+const BRAND = "π-plans";
+
+/** `HH:MM:SS` since the run started. */
+export function formatElapsed(startedAt: string): string {
+	const started = Date.parse(startedAt);
+	if (Number.isNaN(started)) return "00:00:00";
+	const total = Math.max(0, Math.floor((Date.now() - started) / 1000));
+	const h = String(Math.floor(total / 3600)).padStart(2, "0");
+	const m = String(Math.floor((total % 3600) / 60)).padStart(2, "0");
+	const sec = String(total % 60).padStart(2, "0");
+	return `${h}:${m}:${sec}`;
+}
+
+/**
+ * Title row: `┌─ π-plans: <plan> ───┐`, brand in the accent colour, the rest
+ * muted. Colours are emitted as *sequential* balanced spans rather than nested:
+ * a theme `fg()` closes with the default-foreground reset, so wrapping a muted
+ * span around an accent one would leave everything after it unstyled.
+ */
+function titleRow(topic: string, width: number, theme?: DashboardTheme): string {
+	const inner = Math.max(0, width - 2);
+	const prefix = "─ ";
+	const sep = ": ";
+	const used = prefix.length + BRAND.length + sep.length;
+	const name = clip(topic, Math.max(0, inner - used));
+	const fill = "─".repeat(Math.max(0, inner - used - visibleWidth(name)));
+	const rest = `${sep}${name}${fill}┐`;
+	if (!theme) return `┌${prefix}${BRAND}${rest}`;
+	// The left corner rides in the first muted span so the whole border is one colour.
+	return theme.fg("muted", `┌${prefix}`) + theme.fg("accent", BRAND) + theme.fg("muted", rest);
+}
+
+/**
+ * Progress row: `Tasks 3/10 · Verification checks 1/6 · 00:04:12 ███░░░░░░░░`.
+ * The bar, then the elapsed time, then the counts are dropped in that order
+ * when the terminal is too narrow to hold them, so the counts always survive.
+ */
+function progressRow(
+	model: DashboardModel,
+	done: number,
+	total: number,
+	vcDone: number,
+	width: number,
+	narrow: boolean,
+): string {
+	const inner = Math.max(0, width - 2);
+	const counts = `Tasks ${done}/${total} · Verification checks ${vcDone}/${model.checklist.length}`;
+	const elapsed = ` · ${formatElapsed(model.startedAt)}`;
+	const bar = ` ${progressBar(done, total, narrow ? 8 : 12)}`;
+	let body = ` ${counts}${elapsed}${bar}`;
+	if (visibleWidth(body) > inner) body = ` ${counts}${elapsed}`;
+	if (visibleWidth(body) > inner) body = ` ${counts}`;
+	return boxRow("│", body, " ", width);
+}
+
+/** Compact widget lines (aboveEditor). Adapts to width: <64 narrow. */
+export function renderDashboardLines(model: DashboardModel, width: number, theme?: DashboardTheme): string[] {
+	const p = taskProgress(model.tasks);
+	const cur = currentTask(model.tasks);
+	const vcDone = model.checklist.filter((item) => item.done).length;
+	const narrow = width < 64;
+	const lines: string[] = [];
+	const inner = Math.max(0, width - 2);
+	lines.push(titleRow(model.topic, width, theme));
+	lines.push(progressRow(model, p.done, p.total, vcDone, width, narrow));
+	if (model.paused) {
+		lines.push(boxRow("│", ` ⏸ ${clip(model.pausedReason ?? "paused", inner - 3)}`, " ", width));
+	} else if (cur) {
+		const waveLine = narrow ? `▸ ${cur.id} (w${cur.wave})` : `▸ ${cur.id} (wave ${cur.wave}/${maxWave(model.tasks)}): ${cur.title}`;
+		lines.push(boxRow("│", ` ${clip(waveLine, inner - 2)}`, " ", width));
+		if (!narrow && cur.files.length > 0) {
+			lines.push(boxRow("│", `   ${clip(cur.files.join(", "), inner - 4)}`, " ", width));
+		}
+	} else if (allTasksTerminal(model.tasks)) {
+		const auditLine = model.auditFailed.length > 0
+			? `audit: ${model.auditFailed.length} check(s) failed — rollback pending`
+			: model.auditRounds !== null
+				? "audit complete ✓"
+				: "all tasks terminal — audit pending";
+		lines.push(boxRow("│", ` ${clip(auditLine, inner - 2)}`, " ", width));
+	}
+	if (!narrow && model.auditFailed.length > 0) {
+		lines.push(boxRow("│", ` ✗ ${clip(model.auditFailed.join(", "), inner - 3)}`, " ", width));
+	}
+	lines.push(boxRow("└", "─ Ctrl+Shift+T tree", "─", width, "┘"));
+	// The title row carries its own colours; every other row is muted.
+	const painted = theme ? lines.map((line, i) => (i === 0 ? line : theme.fg("muted", line))) : lines;
+	return clampLines(painted, width);
+}
+
+function progressBar(done: number, total: number, width = 12): string {
+	if (total <= 0) return "";
+	const filled = Math.round((done / total) * width);
+	return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+}
+
+export function deriveDashboardModel(
+	topic: string,
+	tasks: TaskView[],
+	checklist: CheckItem[],
+	extra?: { paused?: boolean; pausedReason?: string; auditRounds?: number | null; auditFailed?: string[]; startedAt?: string; usage?: { inToks: number; outToks: number } },
+): DashboardModel {
+	return {
+		topic,
+		tasks,
+		checklist,
+		paused: extra?.paused ?? false,
+		pausedReason: extra?.pausedReason,
+		auditRounds: extra?.auditRounds ?? null,
+		auditFailed: extra?.auditFailed ?? [],
+		startedAt: extra?.startedAt ?? new Date().toISOString(),
+		usage: extra?.usage ?? { inToks: 0, outToks: 0 },
+	};
+}
+
+/** Status-bar summary line (single line, language-neutral symbols). */
+export function formatDashboardSummaryLine(model: DashboardModel): string {
+	const p = taskProgress(model.tasks);
+	const vcDone = model.checklist.filter((item) => item.done).length;
+	const cur = currentTask(model.tasks);
+	const wave = cur ? ` · wave ${cur.wave}` : "";
+	const audit = model.auditRounds !== null ? ` · audit r${model.auditRounds}` : "";
+	const pause = model.paused ? " · ⏸ paused" : "";
+	return `plans: ${model.topic} ▸ tasks ${p.done}/${p.total} · VC ${vcDone}/${model.checklist.length}${wave}${audit}${pause}`;
+}
+
+/** Expanded tree view lines (Ctrl+Shift+T overlay). Wide layout from 96 cols. */
+export function renderDashboardTreeLines(model: DashboardModel, width: number, theme?: DashboardTheme): string[] {
+	const p = taskProgress(model.tasks);
+	const vcDone = model.checklist.filter((item) => item.done).length;
+	const cur = currentTask(model.tasks);
+	const wide = width >= 96;
+	const lines: string[] = [];
+	lines.push(`${model.topic} — task tree (${p.done}/${p.total} done · VC ${vcDone}/${model.checklist.length})${model.paused ? " · ⏸ paused" : ""}`);
+	const row = (task: TaskView, depth: number): void => {
+		const indent = "  ".repeat(depth);
+		const marker = taskMarker(task, cur?.id ?? null);
+		const title = wide ? task.title : clip(task.title, 48);
+		let line = `${indent}${marker} ${task.id}: ${title}`;
+		if (wide && task.files.length > 0) line += `  [${task.files.join(", ")}]`;
+		if (wide && task.deps.length > 0) line += `  (deps: ${task.deps.join(", ")})`;
+		if (task.status === "skipped" && task.skipReason) line += `  ~${task.skipReason}`;
+		if (task.status === "complete" && task.evidence) line += `  ✓${clip(task.evidence, 40)}`;
+		lines.push(line);
+		for (const child of task.children) row(child, depth + 1);
+	};	for (const task of model.tasks) row(task, 0);
+	lines.push("");
+	lines.push("Verification checks:");
+	for (const item of model.checklist) {
+		const mark = model.auditFailed.includes(item.id) ? "✗" : item.done ? "☑" : "☐";
+		lines.push(`  ${mark} ${item.id}${wide ? ` ${clip(item.text.split(";")[1] ?? item.text, Math.min(80, width))}` : ""}`);
+	}
+	if (model.auditRounds !== null) {
+		lines.push("");
+		lines.push(`Completion audit: round ${model.auditRounds}${model.auditFailed.length > 0 ? ` — failed: ${model.auditFailed.join(", ")}` : " — passed ✓"}`);
+	}
+	const painted = theme ? lines.map((line) => theme.fg("muted", line)) : lines;
+	return clampLines(painted, width);
+}
+
+/** Flat open-task summary for injections: current wave first. */
+export function openTaskSummary(tasks: TaskView[]): string {
+	const cur = currentTask(tasks);
+	if (!cur) return "(none — all tasks terminal)";
+	const open = flattenTaskViews(tasks).filter((task) => !taskIsTerminal(task));
+	const currentWave = cur.wave;
+	const inWave = open.filter((task) => task.wave === currentWave).map((task) => task.id);
+	const later = open.filter((task) => task.wave > currentWave).map((task) => task.id);
+	const parts = [`current wave ${currentWave}: ${inWave.join(", ") || "(none)"}`];
+	if (later.length > 0) parts.push(`later waves: ${later.join(", ")}`);
+	return parts.join(" · ");
+}