pi-plans 0.1.1 → 0.1.2

package/src/execution-panel.ts

@@ -2,7 +2,15 @@ import * as fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { CheckItem } from "./plan.ts";
+import {
+	extractCoverage,
+	resolveImplStatuses,
+	shortImplDescription,
+	type CheckItem,
+	type ImplDisplayState,
+	type ImplItem,
+	type ImplMarkerState,
+} from "./plan.ts";
 
 /** SGR runs plus OSC hyperlinks: escaped bytes, no display columns. */
 const ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
@@ -125,6 +133,8 @@ export interface ExecutionPanelState {
 export interface ExecutionPanelExecutionLike {
 	planPath: string;
 	items: CheckItem[];
+	implItems?: ImplItem[];
+	implStatus?: Record<string, ImplMarkerState>;
 	panel?: ExecutionPanelState;
 }
 
@@ -395,21 +405,124 @@ function renderItemLines(item: CheckItem, summary: ItemDiffSummary | undefined,
 	return lines;
 }
 
+function formatElapsed(startedAt: string): string {
+	const total = Math.max(0, Math.floor((Date.now() - Date.parse(startedAt)) / 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}`;
+}
+
+function formatToks(tokens: number): string {
+	const n = Math.max(0, Math.round(tokens));
+	return n < 1000 ? String(n) : `${(n / 1000).toFixed(1)}k`;
+}
+
+/**
+ * Single source for the ⌛ progress count (I-based with zero-coverage
+ * exclusion, VC fallback) — shared by the footer line and the panel header.
+ */
+export function computeExecutionProgress(execution: ExecutionPanelExecutionLike & {
+	usage?: { inToks: number; outToks: number };
+	implStatus?: Record<string, ImplMarkerState>;
+}): { done: number; total: number } {
+	const implItems = execution.implItems ?? [];
+	if (implItems.length) {
+		const statuses = resolveImplStatuses(implItems, execution.items, execution.implStatus);
+		const counted = implItems.filter((impl) =>
+			execution.items.some((item) => extractCoverage(item.text).includes(impl.id)),
+		);
+		if (counted.length > 0) {
+			return {
+				done: counted.filter((impl) => statuses[impl.id] === "vc-passed").length,
+				total: counted.length,
+			};
+		}
+	}
+	return {
+		done: execution.items.filter((item) => item.done).length,
+		total: execution.items.length,
+	};
+}
+
+/**
+ * The `⌛ plans x/y: spent ...` line. Plain text — callers apply theme color.
+ * Shared by the footer line (collapsed) and the panel header (expanded).
+ */
+export function formatExecutionStatusLine(
+	execution: ExecutionPanelExecutionLike & {
+		startedAt: string;
+		usage: { inToks: number; outToks: number };
+		implStatus?: Record<string, ImplMarkerState>;
+	},
+): string {
+	const progress = computeExecutionProgress(execution);
+	return `⌛ plans ${progress.done}/${progress.total}: spent ${formatElapsed(execution.startedAt)} · ${formatToks(execution.usage.inToks)} in-toks · ${formatToks(execution.usage.outToks)} out-toks`;
+}
+
 function renderPanelLines(execution: ExecutionPanelExecutionLike, theme: ThemeLike, width: number): string[] {
-	// Expanded detail view only: the count/hint live in the bottom status bar,
-	// so the panel below the editor never repeats them.
+	// Expanded detail view only: the collapsed count lives in the footer, and
+	// the expanded header re-renders the same line above the item list.
 	const panel = ensurePanelState(execution);
 	if (!panel.expanded) return [""];
 	const lines: string[] = [];
-	for (const item of execution.items) {
-		const summary = panel.itemSummaries[item.id]?.summary;
-		lines.push(...renderItemLines(item, summary, theme, width));
+	const header = formatExecutionStatusLine(
+		execution as ExecutionPanelExecutionLike & {
+			startedAt: string;
+			usage: { inToks: number; outToks: number };
+		},
+	);
+	lines.push(truncateAnsi(theme.fg("accent", header), width));
+	if (execution.implItems?.length) {
+		lines.push(...renderImplGroupedLines(execution, theme, width));
+	} else {
+		// Legacy fallback: plans without a parsable Implementation Items section.
+		for (const item of execution.items) {
+			const summary = panel.itemSummaries[item.id]?.summary;
+			lines.push(...renderItemLines(item, summary, theme, width));
+		}
 	}
 	return lines.length ? lines : [""];
 }
 
+const IMPL_LABELS: Record<ImplDisplayState, string> = {
+	pending: "[Pending]",
+	implementing: "[Implementing]",
+	implemented: "[Implemented]",
+	validating: "[Validating]",
+	"vc-passed": "[VC passed]",
+};
+
+const IMPL_COLORS: Record<ImplDisplayState, string> = {
+	pending: "muted",
+	implementing: "accent",
+	implemented: "accent",
+	validating: "warning",
+	"vc-passed": "success",
+};
+
+function renderImplGroupedLines(execution: ExecutionPanelExecutionLike, theme: ThemeLike, width: number): string[] {
+	const implItems = execution.implItems ?? [];
+	const statuses = resolveImplStatuses(implItems, execution.items, execution.implStatus);
+	const lines: string[] = [];
+
+	for (const impl of implItems) {
+		const status = statuses[impl.id] ?? "pending";
+		let line = `${IMPL_LABELS[status]} ${impl.id}: ${shortImplDescription(impl.text)}`;
+		if (status === "vc-passed") {
+			// Final state: strike through the entire line.
+			line = theme.strikethrough(theme.fg(IMPL_COLORS[status], line));
+		} else {
+			line = theme.fg(IMPL_COLORS[status], line);
+		}
+		lines.push(truncateAnsi(line, width));
+	}
+	return lines;
+}
+
 interface WidgetThemeSource {
 	theme: ThemeLike | null;
+	requestRender: (() => void) | null;
 }
 
 let renderCacheWidth: number | null = null;
@@ -446,7 +559,7 @@ class ExecutionPanelWidget implements WidgetLike {
 // a full TUI relayout mid-stream). Registration is tied to the host `ctx.ui`
 // instance so replacement hosts (extension reload, tests) register afresh.
 let panelRef: { current: ExecutionPanelExecutionLike | null } = { current: null };
-const themeSource: WidgetThemeSource = { theme: null };
+const themeSource: WidgetThemeSource = { theme: null, requestRender: null };
 let registeredUi: unknown = null;
 
 export function refreshExecutionPanel(ctx: ExtensionContext, execution: ExecutionPanelExecutionLike | null): void {
@@ -455,30 +568,51 @@ export function refreshExecutionPanel(ctx: ExtensionContext, execution: Executio
 		return;
 	}
 	if (!execution.panel?.expanded) {
-		// Collapsed: the bottom status bar carries the count; no panel widget.
-		clearExecutionPanel(ctx);
+		// Collapsed: footer carries the ⌛ line; no panel widget is needed. Clear
+		// only when a live expanded widget exists, so repeated progress refreshes
+		// do not re-register or tear down the widget slot.
+		const hadWidget = panelRef.current !== null || registeredUi !== null;
+		panelRef.current = null;
+		registeredUi = null;
+		themeSource.requestRender = null;
+		invalidateRenderCache();
+		if (hadWidget) ctx.ui.setWidget(WIDGET_ID, undefined);
+		ctx.ui.setStatus("pi-plans", ctx.ui.theme.fg("accent", formatExecutionStatusLine(
+			execution as ExecutionPanelExecutionLike & {
+				startedAt: string;
+				usage: { inToks: number; outToks: number };
+			},
+		)));
 		return;
 	}
 	panelRef.current = execution;
 	invalidateRenderCache(); // next render always reflects the latest state
-	if (registeredUi === ctx.ui) {
-		// Same host, same widget slot: nothing to re-register.
-		return;
+	const sameHost = registeredUi === ctx.ui;
+	if (!sameHost) {
+		registeredUi = ctx.ui;
+		themeSource.requestRender = null;
+		ctx.ui.setWidget(
+			WIDGET_ID,
+			(tui, theme) => {
+				themeSource.theme = theme as ThemeLike;
+				const render = (tui as { requestRender?: unknown }).requestRender;
+				themeSource.requestRender = typeof render === "function" ? () => (render as () => void)() : null;
+				return new ExecutionPanelWidget(themeSource);
+			},
+			{ placement: "belowEditor" },
+		);
 	}
-	registeredUi = ctx.ui;
-	ctx.ui.setWidget(
-		WIDGET_ID,
-		(_tui, theme) => {
-			themeSource.theme = theme as ThemeLike;
-			return new ExecutionPanelWidget(themeSource);
-		},
-		{ placement: "belowEditor" },
-	);
+	// Expanded: the panel renders the ⌛ header itself. Clear the footer copy
+	// only when the view is first mounted or the host changes, then request a
+	// render for in-place progress updates.
+	if (!sameHost) ctx.ui.setStatus("pi-plans", undefined);
+	themeSource.requestRender?.();
 }
 
 export function clearExecutionPanel(ctx: ExtensionContext): void {
 	panelRef.current = null;
 	registeredUi = null;
+	themeSource.requestRender = null;
 	invalidateRenderCache();
 	ctx.ui.setWidget(WIDGET_ID, undefined);
 }

package/src/plan.ts

@@ -35,6 +35,112 @@ export function scanDoneMarkers(text: string): string[] {
 	return [...text.matchAll(/\[DONE:(VC-\d+)\]/g)].map((match) => match[1]);
 }
 
+export type ImplMarkerState = "implemented" | "validating";
+
+export interface ImplMarker {
+	id: string;
+	state: ImplMarkerState;
+}
+
+/** Extract every [I-xxx:implemented|validating] marker from an assistant message. */
+export function scanImplMarkers(text: string): ImplMarker[] {
+	return [...text.matchAll(/\[(I-\d+):(implemented|validating)\]/g)].map((match) => ({
+		id: match[1],
+		state: match[2] as ImplMarkerState,
+	}));
+}
+
+export interface ImplItem {
+	id: string;
+	text: string;
+}
+
+/**
+ * Parse the `## Implementation Items` section of a PLAN_vN.md. Strict grammar:
+ * top-level `- `I-001`: text` single lines only; multi-line bodies and nested
+ * sub-bullets are ignored (text stops at end of the first line).
+ */
+export function parseImplItems(planText: string): ImplItem[] {
+	const lines = planText.split("\n");
+	const headerIndex = lines.findIndex((line) => /^##\s+Implementation Items\s*$/.test(line.trim()));
+	if (headerIndex < 0) return [];
+	const items: ImplItem[] = [];
+	const seen = new Set<string>();
+	for (let i = headerIndex + 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (/^##\s/.test(line.trim())) break; // next section ends the items
+		const match = line.match(/^\s*-\s+`(I-\d+)`\s*:\s+(.*)$/);
+		if (!match) continue;
+		const id = match[1];
+		if (seen.has(id)) continue;
+		seen.add(id);
+		items.push({ id, text: match[2].trim() });
+	}
+	return items;
+}
+
+/**
+ * One-sentence description: cut at the first sentence boundary (。/.) or
+ * semicolon (；/;), then cap at 80 characters with an ellipsis.
+ */
+export function shortImplDescription(text: string): string {
+	const clipped = text.split(/[。；;]/)[0] ?? text;
+	const sentence = clipped.split(/(?<=[.])\s/)[0] ?? clipped;
+	const trimmed = sentence.trim();
+	if (trimmed.length <= 80) return trimmed;
+	return `${trimmed.slice(0, 79)}…`;
+}
+
+/**
+ * Extract the covered I-ids from a VC checklist line's coverage clause
+ * ("`VC-001` covers `I-002` and `I-003`; pass condition: ..." → ["I-002",
+ * "I-003"]). Only references before the first ";" count.
+ */
+export function extractCoverage(vcText: string): string[] {
+	const clause = vcText.split(";")[0] ?? "";
+	return [...clause.matchAll(/\bI-\d+\b/g)].map((match) => match[0]);
+}
+
+export type ImplDisplayState = "pending" | "implementing" | "implemented" | "validating" | "vc-passed";
+
+/**
+ * Resolve the display state for every I-item. Precedence: vc-passed (all
+ * covering VCs done, final) > explicit marker (validating / implemented) >
+ * derivation (some covering VC done → validating; first I with no covering
+ * VC done → implementing; rest → pending).
+ */
+export function resolveImplStatuses(
+	implItems: ImplItem[],
+	items: CheckItem[],
+	implStatus: Record<string, ImplMarkerState> | undefined,
+): Record<string, ImplDisplayState> {
+	const result: Record<string, ImplDisplayState> = {};
+	let frontierAssigned = false;
+	for (const impl of implItems) {
+		const coverage = items.filter((item) => extractCoverage(item.text).includes(impl.id));
+		if (coverage.length > 0 && coverage.every((item) => item.done)) {
+			result[impl.id] = "vc-passed";
+			continue;
+		}
+		const marker = implStatus?.[impl.id];
+		if (marker === "validating" || marker === "implemented") {
+			result[impl.id] = marker;
+			continue;
+		}
+		if (coverage.some((item) => item.done)) {
+			result[impl.id] = "validating";
+			continue;
+		}
+		if (!frontierAssigned) {
+			result[impl.id] = "implementing";
+			frontierAssigned = true;
+			continue;
+		}
+		result[impl.id] = "pending";
+	}
+	return result;
+}
+
 export interface PlanVersionFile {
 	path: string;
 	version: number;

package/src/state.ts

@@ -34,11 +34,18 @@ export interface RoleConfig {
 	confirmed_at: string | null;
 }
 
+export interface ExecutionConfig {
+	model_selector: string | null;
+	source: SettingSource;
+	updated_at: string | null;
+}
+
 export interface PlansConfig {
 	schema: number;
 	language: LanguageConfig;
 	reviewer: RoleConfig;
 	criticizer: RoleConfig;
+	execution: ExecutionConfig;
 	artifact_root: string;
 	artifact_root_source: SettingSource;
 	artifact_root_updated_at: string | null;
@@ -69,6 +76,11 @@ export const DEFAULT_CONFIG: PlansConfig = {
 		name_prefix: "pi-plans-criticizer",
 		confirmed_at: null,
 	},
+	execution: {
+		model_selector: null,
+		source: "unset",
+		updated_at: null,
+	},
 	artifact_root: DEFAULT_ARTIFACT_ROOT,
 	artifact_root_source: "unset",
 	artifact_root_updated_at: null,
@@ -316,6 +328,22 @@ export function setArtifactRoot(workdir: string, artifactRoot: string, source: "
 	return { config, stateRoot, notices };
 }
 
+export interface SetExecutionModelOptions {
+	modelSelector?: string;
+	source: "user" | "auto";
+}
+
+export function setExecutionModel(workdir: string, options: SetExecutionModelOptions): EnsureResult {
+	const { config, stateRoot, notices } = ensureState(workdir);
+	config.execution = {
+		model_selector: options.modelSelector === undefined || options.modelSelector === "inherit" ? null : options.modelSelector,
+		source: options.source,
+		updated_at: utcNow(),
+	};
+	atomicWriteJson(path.join(stateRoot, "config.json"), config);
+	return { config, stateRoot, notices };
+}
+
 export interface SetRoleOptions {
 	role: "reviewer" | "criticizer";
 	mode?: string;
@@ -359,6 +387,7 @@ export interface StartRunOptions {
 	topic: string;
 	skill: string;
 	requestText: string;
+	onStart?: (run: RunInfo) => void;
 }
 
 export interface StartRunResult {
@@ -408,6 +437,13 @@ export function startRun(workdir: string, options: StartRunOptions): StartRunRes
 		run_dir: runDir,
 		artifact_dir: artifactDir,
 	} satisfies ActiveInfo);
+	if (options.onStart) {
+		try {
+			options.onStart(run);
+		} catch {
+			/* marker failure is non-fatal: planning start should not abort when the entry appender rejects */
+		}
+	}
 	return { run, notices };
 }