@quantmind-br/pi-goal-x 0.0.0-stage → 0.35.1

package/extensions/goal-status.ts

@@ -0,0 +1,305 @@
+import { commandHint, type GoalCommands } from "./goal-controls.ts";
+import type { GoalKeybindings } from "./goal-settings.ts";
+/**
+ * /goal-status text builder (plan §13).
+ *
+ * Renders the SAME shared dashboard model as the above-editor widget: the
+ * standard mode composes a static compact-dashboard box, the current-task
+ * details block, recent activity, and the last audit result; verbose mode adds
+ * the full diagnostic detail (§13.2). Pure module — no TUI imports, no ctx —
+ * so the exact text is unit-testable and can never drift from the widget.
+ */
+
+import { truncateText } from "./goal-core.ts";
+import type { GoalLedgerEvent, GoalLedgerEvent as LedgerEvent } from "./goal-ledger.ts";
+import { latestAuditorResultForGoal, latestAuditForGoal, latestEventsForGoal } from "./goal-ledger.ts";
+import type { GoalRecord, GoalTask } from "./goal-record.ts";
+import { deriveGoalDashboardModel, formatCompactTokens, formatDashboardDuration } from "./widgets/goal-dashboard-model.ts";
+import {
+	renderActivityBlock,
+	renderCompactDashboard,
+	renderCurrentTaskBlock,
+	renderUnfocusedDashboard,
+} from "./widgets/goal-dashboard-renderer.ts";
+import { formatCheckpointHealthReport, type CheckpointHealth } from "./goal-session-health.ts";
+
+/** Fixed rendering width for the notify text (medium layout mode). */
+export const GOAL_STATUS_WIDTH = 78;
+
+/** Identity theme: the box text is emitted as plain text for ctx.ui.notify. */
+export const PLAIN_THEME = {
+	fg: (_color: string, value: string) => value,
+	bold: (value: string) => value,
+} as never;
+
+export interface GoalStatusTextOptions {
+	commands?: GoalCommands;
+	keybindings?: GoalKeybindings;
+	maxAutonomousRuns?: number;
+	idleContinuationBackoff?: boolean;
+	goal: GoalRecord | null;
+	focused: boolean;
+	otherOpenGoals: number;
+	ledgerEvents?: GoalLedgerEvent[];
+	ledgerMalformed?: number;
+	verbose?: boolean;
+	health?: boolean;
+	/** Supplied by the command layer only for the explicit health check. */
+	activeFilePresent?: boolean;
+	/** Issue #30: persisted-checkpoint report for this session (health view only). */
+	checkpointHealth?: CheckpointHealth | null;
+	checkpointSessionFile?: string;
+	/** Effective settings lines with provenance (verbose only). */
+	settingsReport?: string[];
+	width?: number;
+}
+
+/**
+ * Build the /goal-status text.
+ *
+ * Standard (§13.1): static compact-dashboard rendering + current-task details
+ * + recent activity + last audit result when available. The terminology and
+ * hierarchy match the expanded dashboard (§13.3); no effective settings by
+ * default.
+ *
+ * Verbose (§13.2): goal id, revision, full objective, complete task tree with
+ * full evidence and contracts, recent ledger history, effective settings and
+ * provenance, token budget detail, pause/blocker detail, paths, and the last
+ * audit report.
+ */
+export function buildGoalStatusText(options: GoalStatusTextOptions): string {
+	const width = options.width ?? GOAL_STATUS_WIDTH;
+	if (options.health) return buildHealthStatus(options, width);
+	if (!options.goal) {
+		return options.otherOpenGoals > 0
+			? renderUnfocusedDashboard(options.otherOpenGoals, PLAIN_THEME, width, options.commands).join("\n")
+			: `No goal is set. Use ${commandHint("goal", options.commands)} or ${commandHint("sisyphus", options.commands)} to draft a goal.`;
+	}
+	const events = options.ledgerEvents ?? [];
+	const model = deriveGoalDashboardModel(options.goal, {
+		focused: options.focused,
+		maxAutonomousRuns: options.maxAutonomousRuns,
+		idleContinuationBackoff: options.idleContinuationBackoff,
+		commands: options.commands,
+		otherOpenGoals: options.otherOpenGoals,
+		ledgerEvents: events,
+	});
+	if (!model) return "No goal is set.";
+
+	if (options.verbose) {
+		return buildVerboseStatus(options.goal, model, events, options.settingsReport ?? [], width);
+	}
+
+	const parts: string[] = [];
+	parts.push(renderCompactDashboard(model, PLAIN_THEME, width, { footerHint: `Run ${commandHint("goal-status", options.commands)} verbose for full detail`, keybindings: options.keybindings?.dashboard, auditorKey: options.keybindings?.toggleAuditor }).join("\n"));
+	if (model.currentTask) {
+		parts.push(renderCurrentTaskBlock(model, PLAIN_THEME, width).join("\n"));
+	}
+	if (model.recentActivity.length > 0) {
+		parts.push(renderActivityBlock(model.recentActivity, PLAIN_THEME, width).join("\n"));
+	}
+	const audit = latestAuditorResultForGoal(events, model.goalId);
+ if (latestAuditForGoal(events, model.goalId)?.type === "audit_started") parts.push("Latest audit: no recorded result.");
+	if (audit) {
+		parts.push(lastAuditBlock(audit, width));
+	}
+	return parts.join("\n\n");
+}
+
+interface HealthCheck {
+	label: string;
+	value: string;
+	severity: "ok" | "warn" | "error";
+}
+
+/**
+ * Render a concise, read-only integrity report. This deliberately checks
+ * storage/runtime coherence only; it does not infer that the work itself is
+ * complete from task counts or contracts.
+ */
+function buildHealthStatus(options: GoalStatusTextOptions, width: number): string {
+	const goal = options.goal;
+	if (!goal) {
+		const focus = options.otherOpenGoals > 0
+			? `WARN — no goal is focused; ${options.otherOpenGoals} open goal${options.otherOpenGoals === 1 ? "" : "s"} remain.`
+			: "OK — no goal is focused and there are no open goals.";
+		return ["Goal health: " + (options.otherOpenGoals > 0 ? "WARN" : "OK"), `Focus: ${focus}`, "Run /goal-status for the normal dashboard."].join("\n");
+	}
+
+	const checks: HealthCheck[] = [];
+	checks.push({
+		label: "Focus",
+		value: options.focused ? "focused" : "not focused",
+		severity: options.focused ? "ok" : "warn",
+	});
+	checks.push({
+		label: "Lifecycle",
+		value: `${statusLabelForHealth(goal)}${goal.autoContinue ? " · auto-continue on" : " · auto-continue off"}`,
+		severity: goal.status === "active" || goal.status === "paused" || goal.status === "blocked" || goal.status === "budget_limited" || goal.status === "complete" ? "ok" : "error",
+	});
+
+	if (goal.status !== "complete") {
+		const fileSeverity = options.activeFilePresent === false ? "error" : options.activeFilePresent === true ? "ok" : "warn";
+		checks.push({
+			label: "Goal file",
+			value: goal.activePath ? (options.activeFilePresent === false ? `missing · ${goal.activePath}` : goal.activePath) : "missing active path",
+			severity: fileSeverity,
+		});
+	}
+
+	const malformed = options.ledgerMalformed ?? 0;
+	checks.push({
+		label: "Ledger",
+		value: malformed > 0 ? `${malformed} malformed entr${malformed === 1 ? "y" : "ies"}` : "valid",
+		severity: malformed > 0 ? "warn" : "ok",
+	});
+
+	if (goal.taskList) {
+		const tasks = flattenHealthTasks(goal.taskList.tasks);
+		const completed = tasks.filter((task) => task.status === "complete" || task.status === "skipped").length;
+		const pending = tasks.length - completed;
+		const contractedPending = tasks.filter((task) => task.status === "pending" && Boolean(task.verificationContract?.trim())).length;
+		checks.push({
+			label: "Tasks",
+			value: `${completed}/${tasks.length} terminal · ${pending} pending${contractedPending > 0 ? ` · ${contractedPending} contracted` : ""}`,
+			severity: goal.taskList.blockCompletion && pending > 0 ? "warn" : "ok",
+		});
+	}
+
+	if (typeof goal.tokenBudget === "number" && goal.tokenBudget > 0) {
+		const percentage = Math.round((goal.usage.tokensUsed / goal.tokenBudget) * 100);
+		checks.push({
+			label: "Budget",
+			value: `${formatCompactTokensForHealth(goal.usage.tokensUsed)} / ${formatCompactTokensForHealth(goal.tokenBudget)} (${Math.max(0, percentage)}%)`,
+			severity: goal.status === "budget_limited" || percentage >= 100 ? "warn" : percentage >= 90 ? "warn" : "ok",
+		});
+	}
+
+	const overall = checks.some((check) => check.severity === "error") ? "ERROR" : checks.some((check) => check.severity === "warn") ? "WARN" : "OK";
+	const lines = [`Goal health: ${overall}`, `Goal: ${truncateText(goal.objective, Math.max(20, width - 12))}`];
+	for (const check of checks) lines.push(`${check.severity === "error" ? "ERROR" : check.severity === "warn" ? "WARN" : "OK"} ${check.label}: ${check.value}`);
+	if (options.checkpointHealth && options.checkpointHealth.total > 0) {
+		lines.push("");
+		lines.push(formatCheckpointHealthReport(options.checkpointHealth, options.checkpointSessionFile));
+	}
+	lines.push("", "This is a storage/runtime health check, not a completion verdict.");
+	return lines.join("\n");
+}
+
+function flattenHealthTasks(tasks: GoalTask[]): GoalTask[] {
+	const result: GoalTask[] = [];
+	for (const task of tasks) {
+		result.push(task);
+		if (task.subtasks) result.push(...flattenHealthTasks(task.subtasks));
+	}
+	return result;
+}
+
+function statusLabelForHealth(goal: GoalRecord): string {
+	return goal.status === "budget_limited" ? "budget limited" : goal.status;
+}
+
+function formatCompactTokensForHealth(value: number): string {
+	if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+	if (value >= 1_000) return `${(value / 1_000).toFixed(1).replace(/\.0$/, "")}K`;
+	return String(Math.max(0, Math.floor(value)));
+}
+
+function lastAuditBlock(
+	audit: { verdict: "approved" | "disapproved" | "error"; report: string; at: string },
+	width: number,
+): string {
+	const verdictLabel = audit.verdict === "approved" ? "APPROVED" : audit.verdict === "disapproved" ? "CHANGES REQUIRED" : "ERROR";
+	const line = `Last audit: ${verdictLabel} (${audit.at.slice(0, 10)}) — ${truncateText(audit.report.replace(/\s+/g, " "), 90)}`;
+	const inner = Math.max(4, width - 2);
+	return [
+		`╭─ Audit result ─ ${verdictLabel} ${"─".repeat(Math.max(1, inner - visibleLen(`─ Audit result ─ ${verdictLabel} `) - 1))}╮`,
+		`│ ${truncateText(line, inner - 2)}${" ".repeat(Math.max(0, inner - 2 - truncateText(line, inner - 2).length))}│`,
+		`╰${"─".repeat(inner)}╯`,
+	].join("\n");
+}
+
+function visibleLen(value: string): number {
+	return value.length;
+}
+
+// ── Verbose (§13.2) ─────────────────────────────────────────────────────────
+
+function buildVerboseStatus(goal: GoalRecord, model: ReturnType<typeof deriveGoalDashboardModel>, events: GoalLedgerEvent[], settingsReport: string[], _width: number): string {
+	const lines: string[] = [];
+	lines.push(`Goal id: ${goal.id}`);
+	lines.push(...(model?.scheduling ?? []));
+	lines.push(`Revision: ${goal.revision ?? 0}`);
+	lines.push(`Status: ${model?.status.label}${model?.focused ? " (focused)" : " (not focused)"}`);
+	lines.push(`Mode: ${goal.sisyphus ? "sisyphus" : "goal"} · auto-continue: ${goal.autoContinue ? "on" : "off"}`);
+	lines.push(`Usage: ${formatDashboardDuration(goal.usage.activeSeconds)} · ${formatCompactTokens(goal.usage.tokensUsed)} tokens`);
+	if (model?.budget) {
+		lines.push(`Budget: ${formatCompactTokens(model.budget.used)} / ${formatCompactTokens(model.budget.total)} · ${model.budget.percentage}% used · ${formatCompactTokens(model.budget.remaining)} remaining`);
+	}
+	if (goal.pauseReason) lines.push(`Pause/blocker: ${goal.pauseReason}`);
+	if (goal.pauseSuggestedAction) lines.push(`Suggested action: ${goal.pauseSuggestedAction}`);
+	if (goal.activePath) lines.push(`File: ${goal.activePath}`);
+	if (goal.archivedPath) lines.push(`Archive: ${goal.archivedPath}`);
+
+	lines.push("", "Objective:", goal.objective.trim());
+
+	if (goal.verificationContract) {
+		lines.push("", `Verification contract: ${goal.verificationContract.trim()}`);
+	}
+	if (goal.taskList) {
+		lines.push("", `Tasks (${topLevelCount(goal.taskList.tasks)} top-level, ${goal.taskList.tasks.filter((t) => t.status === "complete" || t.status === "skipped").length} done):`);
+		for (const line of renderTaskTreeVerbose(goal.taskList.tasks, 0, goal.currentTaskId)) {
+			lines.push(line);
+		}
+	}
+	if (model?.currentTask) {
+		lines.push("", `Current task: ${model.currentTask.id} · ${model.currentTask.title}${model.currentTask.inferred ? " (inferred)" : ""}`);
+		if (model.currentTask.totalSubtasks > 0) {
+			lines.push(`  subtasks: ${model.currentTask.completedSubtasks}/${model.currentTask.totalSubtasks} (${model.currentTask.subtaskPercentage}%)`);
+		}
+		if (model.currentTask.verificationContract) lines.push(`  contract: ${model.currentTask.verificationContract}`);
+		if (model.currentTask.evidence) lines.push(`  evidence: ${model.currentTask.evidence}`);
+	}
+
+	const recent = latestEventsForGoal(events, goal.id, 12);
+	if (recent.length > 0) {
+		lines.push("", "Recent ledger:");
+		for (const event of recent) {
+			lines.push(`  ${event.at.slice(0, 19)} ${event.type}`);
+		}
+	}
+	const audit = latestAuditorResultForGoal(events, goal.id);
+ if (latestAuditForGoal(events, goal.id)?.type === "audit_started") lines.push("", "Latest audit: no recorded result.");
+	if (audit) {
+		lines.push("", `Last audit (${audit.at.slice(0, 10)}): ${audit.verdict}`);
+		lines.push(truncateText(audit.report.replace(/\s+/g, " "), 400));
+	}
+	if (settingsReport.length > 0) {
+		lines.push("", "Effective settings:");
+		lines.push(...settingsReport.map((line) => `  ${line}`));
+	}
+	return lines.join("\n");
+}
+
+function topLevelCount(tasks: GoalTask[]): number {
+	return tasks.length;
+}
+
+function renderTaskTreeVerbose(tasks: GoalTask[], depth = 0, currentTaskId?: string): string[] {
+	const lines: string[] = [];
+	const indent = "  ".repeat(depth);
+	for (const t of tasks) {
+		const isCurrent = t.id === currentTaskId;
+		const marker = isCurrent ? "▸" : t.status === "complete" ? "✓" : t.status === "skipped" ? "~" : "·";
+		const contract = t.verificationContract ? ` — contract: ${t.verificationContract}` : "";
+		const evidence = t.status === "complete" && t.evidence ? ` — evidence: ${t.evidence}` : "";
+		lines.push(`${indent}${marker} ${t.id}  ${t.title}${contract}${evidence}`);
+		if (t.subtasks && t.subtasks.length > 0) {
+			lines.push(...renderTaskTreeVerbose(t.subtasks, depth + 1, currentTaskId));
+		}
+	}
+	return lines;
+}
+
+// Re-export for consumers that want the same event type.
+export type { LedgerEvent };

package/extensions/goal-task-confirmation.ts

@@ -0,0 +1,174 @@
+import { goalDialogControls } from "./goal-dialog-controls.ts";
+import { truncateToWidth } from "./widgets/text-cache.ts";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { GoalTask } from "./goal-record.ts";
+import { borderedLine, dialogInnerWidth, horizontalRule } from "./widgets/dialog-scaffold.ts";
+
+/** Render a task tree for confirmation dialogs (structural view). */
+export function renderConfirmationTasks(tasks: readonly GoalTask[], indent: number): string[] {
+	const prefix = "  ".repeat(indent);
+	const lines: string[] = [];
+	for (const t of tasks) {
+		const lw = t.lightweightSubtasks ? " (lightweight)" : "";
+		const contract = t.verificationContract ? ` contract: ${t.verificationContract}` : "";
+		lines.push(`${prefix}[ ] ${t.id}: ${t.title}${lw}${contract}`);
+		if (t.subtasks && t.subtasks.length > 0) {
+			lines.push(...renderConfirmationTasks(t.subtasks, indent + 1));
+		}
+	}
+	return lines;
+}
+
+/**
+ * Task-only confirmation boundary (follow-up Stage 2). The complete result is
+ * the user's {decision: confirm | cancel} — no auditor toggle, no
+ * goal-creation wording, and no questionnaire state. `set_goal_tasks` confirms
+ * the STRUCTURAL input here and merges progress only inside GoalService.apply
+ * against the disk-refreshed clone. The dialog is a small self-contained
+ * component with neutral, task-specific labels.
+ */
+export interface TaskConfirmationResult {
+	decision: "confirm" | "cancel";
+}
+
+export async function showTaskConfirmation(ctx: ExtensionContext, proposalText: string): Promise<TaskConfirmationResult> {
+	if (process.env.PI_GOAL_AUTO_CONFIRM === "1") return { decision: "confirm" };
+	if (!ctx.hasUI) return { decision: process.env.PI_GOAL_AUTO_CONFIRM === "0" ? "cancel" : "confirm" };
+	if (ctx.mode !== "rpc" && typeof ctx.ui.custom === "function") {
+		const result = await showTaskListConfirmationDialog(ctx, proposalText);
+		if (result) return result;
+	}
+	if (typeof ctx.ui.select !== "function") return { decision: "cancel" };
+	const answer = await ctx.ui.select(`Task list confirmation\n\n${proposalText}`, ["Confirm task list", "Keep current tasks"]);
+	return { decision: answer === "Confirm task list" ? "confirm" : "cancel" };
+}
+
+async function showTaskListConfirmationDialog(ctx: ExtensionContext, proposalText: string): Promise<TaskConfirmationResult | undefined> {
+	const controls = goalDialogControls(typeof ctx.cwd === "string" ? ctx.cwd : process.cwd());
+	return await ctx.ui.custom<TaskConfirmationResult | undefined>(
+		(tui: TUI, theme: Theme, _keybindings: unknown, done: (result: TaskConfirmationResult | undefined) => void): Component => {
+			if (!tui || typeof tui.getShowHardwareCursor !== "function" || typeof tui.setShowHardwareCursor !== "function" || typeof tui.requestRender !== "function") {
+				done(undefined);
+				return { render: () => [], invalidate: () => {} };
+			}
+			const wasHardwareCursorShown = tui.getShowHardwareCursor();
+			tui.setShowHardwareCursor(false);
+			// Pause pi's working spinner for the dialog duration: its ~80ms re-renders
+			// write output that snaps a scrolled-up user back to the terminal bottom.
+			ctx.ui.setWorkingVisible(false);
+
+			// Default: "Confirm task list" (matches the pre-existing default).
+			let selectedIndex = 0;
+
+			const OPTIONS: Array<{ label: string; value: TaskConfirmationResult["decision"]; description: string }> = [
+				{
+					label: "Confirm task list",
+					value: "confirm",
+					description: "Replace the current task list with this structure.",
+				},
+				{
+					label: "Keep current tasks",
+					value: "cancel",
+					description: "Leave the existing task list unchanged.",
+				},
+			];
+
+			const BODY_LINES = proposalText.split("\n");
+			const MAX_BODY = 16;
+
+			const accent = (s: string) => theme.fg("accent", s);
+			const dim = (s: string) => theme.fg("dim", s);
+			const muted = (s: string) => theme.fg("muted", s);
+
+			// ── Component ────────────────────────────────────────────────────
+			const component: Component & { dispose?(): void } = {
+				dispose() {
+					tui.setShowHardwareCursor(wasHardwareCursorShown);
+					ctx.ui.setWorkingVisible(true);
+				},
+
+				invalidate(): void {
+					// No cached state to invalidate
+				},
+
+				render(width: number): string[] {
+					const termWidth = Math.min(width, 80);
+					const innerWidth = dialogInnerWidth(termWidth);
+
+					const line = (leftContent: string): string => borderedLine(accent, innerWidth, leftContent);
+
+					const horizLine = horizontalRule(innerWidth);
+					const lines: string[] = [];
+					const p = "  ";
+
+					// ── Header ────────────────────────────────────────────────
+					lines.push(accent(`┌${horizLine}┐`));
+					lines.push(line(p + theme.bold("Task list confirmation")));
+					lines.push(accent(`├${horizLine}┤`));
+
+					// ── Body: the proposed task tree ─────────────────────────
+					const body = BODY_LINES.slice(0, MAX_BODY);
+					for (const raw of body) {
+						const trimmed = raw;
+						lines.push(line(p + truncateToWidth(muted(trimmed || " "), innerWidth - p.length, "…")));
+					}
+					if (BODY_LINES.length > MAX_BODY) {
+						lines.push(line(p + dim(`+${BODY_LINES.length - MAX_BODY} more lines`)));
+					}
+					lines.push(accent(`├${horizLine}┤`));
+
+					// ── Options ─────────────────────────────────────────────
+					OPTIONS.forEach((opt, i) => {
+						const isSelected = i === selectedIndex;
+						const marker = isSelected ? "▸ " : "  ";
+						const label = isSelected ? theme.fg("accent", opt.label) : opt.label;
+						lines.push(line(p + marker + truncateToWidth(label, innerWidth - 6, "…")));
+						if (isSelected) {
+							lines.push(line(p + " ".repeat(4) + truncateToWidth(dim(opt.description), innerWidth - 10, "…")));
+						}
+					});
+
+					// ── Footer ───────────────────────────────────────────────
+					lines.push(accent(`├${horizLine}┤`));
+					lines.push(line(p + dim(`${controls.hint("confirm")} to select  ·  ${controls.navigationHint()} to navigate  ·  ${controls.hint("cancel")} = keep current tasks`)));
+					lines.push(accent(`└${horizLine}┘`));
+
+					return lines;
+				},
+
+				handleInput(data: string): void {
+					if (controls.matches(data, "up")) {
+						selectedIndex = (selectedIndex - 1 + OPTIONS.length) % OPTIONS.length;
+						tui.requestRender();
+						return;
+					}
+					if (controls.matches(data, "down")) {
+						selectedIndex = (selectedIndex + 1) % OPTIONS.length;
+						tui.requestRender();
+						return;
+					}
+					if (controls.matches(data, "confirm")) {
+						done({ decision: OPTIONS[selectedIndex]!.value });
+						return;
+					}
+					if (controls.matches(data, "cancel")) {
+						done({ decision: "cancel" });
+						return;
+					}
+				},
+			};
+
+			return component;
+		},
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "70%",
+				minWidth: 50,
+				maxHeight: "60%",
+			},
+		},
+	);
+}

package/extensions/goal-task-count.ts

@@ -0,0 +1,59 @@
+/**
+ * Single task-counting implementation (P1-10).
+ *
+ * Previously ~5 copies of the same subtree walker lived in goal-policy,
+ * goal-auditor, widgets/goal-widget, widgets/task-list-overlay, and
+ * prompts/goal-prompts, with subtly different shapes. All call sites now use
+ * this one walker. `doneIncludesSkipped` is explicit so "skipped counts as
+ * done" semantics can never drift silently again: today every call site uses
+ * false (skipped is tracked separately, matching prior behavior); the flag
+ * exists for surfaces that deliberately want skipped folded into done.
+ */
+
+import type { GoalTask } from "./goal-record.ts";
+
+export interface TaskSubtreeCounts {
+	total: number;
+	/** Done count: complete, or complete+skipped when doneIncludesSkipped. */
+	complete: number;
+	skipped: number;
+	pending: number;
+	/** Present only when collectPending is requested (prompts' "next pending"). */
+	pendingTasks?: GoalTask[];
+}
+
+export function countTaskSubtree(
+	tasks: readonly GoalTask[],
+	opts: { doneIncludesSkipped?: boolean; collectPending?: boolean } = {},
+): TaskSubtreeCounts {
+	let total = 0;
+	let rawComplete = 0;
+	let rawSkipped = 0;
+	const pendingTasks: GoalTask[] | undefined = opts.collectPending ? [] : undefined;
+
+	function walk(list: readonly GoalTask[]): void {
+		for (const t of list) {
+			total++;
+			if (t.status === "complete") rawComplete++;
+			else if (t.status === "skipped") rawSkipped++;
+			else if (pendingTasks) pendingTasks.push(t);
+			if (t.subtasks && t.subtasks.length > 0) walk(t.subtasks);
+		}
+	}
+	walk(tasks);
+
+	const done = opts.doneIncludesSkipped ? rawComplete + rawSkipped : rawComplete;
+	return {
+		total,
+		complete: done,
+		skipped: rawSkipped,
+		pending: total - rawComplete - rawSkipped,
+		...(opts.collectPending ? { pendingTasks } : {}),
+	};
+}
+
+/** Total node count only (task-list tools / overlay header counts). */
+export function countAllTasks(tasks: readonly GoalTask[] | undefined): number {
+	if (!tasks) return 0;
+	return countTaskSubtree(tasks).total;
+}

package/extensions/goal-task-derive.ts

@@ -0,0 +1,46 @@
+/**
+ * F2: objective→task bootstrap. When a goal is created with no task list and
+ * the objective contains an ordered-step or checklist structure, derive a
+ * proposed task tree so goals start with a trackable, human-approved plan
+ * instead of a blank checklist.
+ */
+
+import type { GoalTask } from "./goal-record.ts";
+
+/**
+ * Derive a proposed task tree from an objective's structure:
+ *   - checklist markers: `- [ ] title` / `[ ] title`
+ *   - ordered steps: `N. title`, `N) title`, `N: title` (≥2 items)
+ * Returns null when the objective has no usable structure (the agent then
+ * proposes tasks conversationally via set_goal_tasks).
+ */
+export function deriveTasksFromObjective(objective: string): GoalTask[] | null {
+	const tasks: GoalTask[] = [];
+	let sawChecklist = false;
+
+	for (const raw of objective.split(/\r?\n/)) {
+		const line = raw.trim();
+		if (!line) continue;
+		// Checklist markers are the strongest signal.
+		const checklist = line.match(/^(?:-\s*)?\[\s\]\s+(.+)$/);
+		if (checklist) {
+			sawChecklist = true;
+			tasks.push({ id: `step-${tasks.length + 1}`, title: checklist[1]!.trim(), status: "pending" });
+			continue;
+		}
+		// Ordered steps at line starts.
+		const numbered = line.match(/^(\d{1,2})\s*[.):]\s+(.+)$/);
+		if (numbered) {
+			tasks.push({ id: `step-${tasks.length + 1}`, title: numbered[2]!.trim(), status: "pending" });
+		}
+	}
+
+	if (tasks.length === 0) return null;
+	if (!sawChecklist && tasks.length < 2) return null; // a lone numbered line is usually a section label
+	return tasks;
+}
+
+/** Human-readable summary of the derived proposal (guidance text). */
+export function derivedTaskCount(objective: string): number {
+	return deriveTasksFromObjective(objective)?.length ?? 0;
+}

package/extensions/goal-task-index.ts

@@ -0,0 +1,57 @@
+import type { GoalTask } from "./goal-record.ts";
+
+export interface TaskIndex {
+ tasks: GoalTask[];
+ byId: Map<string, GoalTask>;
+ ordered: Array<{task: GoalTask; depth: number; parentId?: string}>;
+ pending: GoalTask[];
+ complete: number;
+ skipped: number;
+}
+const cache: Array<{index: TaskIndex; chars: number}> = [];
+let cachedChars = 0;
+const taskFields = ["id", "title", "status", "completedAt", "skippedAt", "evidence", "skipReason", "verificationContract", "lightweightSubtasks"] as const;
+
+/** Compare fields without serializing long titles/contracts. Also catches in-place edits. */
+function sameTasks(left: readonly GoalTask[], right: readonly GoalTask[]): boolean {
+ if (left.length !== right.length) return false;
+ for (let i = 0; i < left.length; i++) {
+  const a = left[i]!; const b = right[i]!;
+  for (const field of taskFields) if (a[field] !== b[field]) return false;
+  if (a.subtasks || b.subtasks) {
+   if (!a.subtasks || !b.subtasks || !sameTasks(a.subtasks, b.subtasks)) return false;
+  }
+ }
+ return true;
+}
+const emptyTasks: GoalTask[] = [];
+/** Content validated: usage-only copies reuse derivations; mutable input never aliases the snapshot. */
+export function taskIndex(tasks: readonly GoalTask[] = emptyTasks): TaskIndex {
+ for (let i = cache.length - 1; i >= 0; i--) {
+  const entry = cache[i]!;
+  if (sameTasks(tasks, entry.index.tasks)) return entry.index;
+ }
+ let chars = 0;
+ const copy = (list: readonly GoalTask[]): GoalTask[] => list.map(task => {
+  for (const field of taskFields) if (typeof task[field] === "string") chars += (task[field] as string).length;
+  return {...task, ...(task.subtasks ? {subtasks: copy(task.subtasks)} : {})};
+ });
+ const snapshot = copy(tasks);
+ const result: TaskIndex = {tasks: snapshot, byId: new Map(), ordered: [], pending: [], complete: 0, skipped: 0};
+ const walk = (list: GoalTask[], depth: number, parentId?: string): void => {
+  for (const task of list) {
+   result.byId.set(task.id, task); result.ordered.push({task, depth, parentId});
+   if (task.status === "pending") result.pending.push(task);
+   else if (task.status === "complete") result.complete++;
+   else result.skipped++;
+   if (task.subtasks) walk(task.subtasks, depth + 1, task.id);
+  }
+ };
+ walk(snapshot, 0);
+// Bound retained text as well as entry count. Oversized plans remain fully supported.
+ if (chars <= 2_000_000) {
+  while (cache.length >= 32 || cachedChars + chars > 2_000_000) cachedChars -= cache.shift()!.chars;
+  cache.push({index: result, chars}); cachedChars += chars;
+ }
+ return result;
+}