@linimin/pi-letscook 0.1.27 → 0.1.29

package/extensions/completion/index.ts

@@ -5,8 +5,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { StringEnum } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { DynamicBorder, parseFrontmatter } from "@mariozechner/pi-coding-agent";
+import { Container, matchesKey, type SelectItem, SelectList, Text } from "@mariozechner/pi-tui";
 import { Type } from "typebox";
 
 const PROTOCOL_ID = "completion";
@@ -115,7 +115,12 @@ type ContextProposal = {
 	acceptance: string[];
 	goalText: string;
 	basisPreview: string;
-	source: "session";
+	source: "session" | "analyst";
+};
+
+type RecentDiscussionEntry = {
+	role: "user" | "assistant" | "custom" | "summary";
+	text: string;
 };
 
 type ContextProposalDecision = {
@@ -123,12 +128,77 @@ type ContextProposalDecision = {
 	goalText: string;
 };
 
+type ContextProposalConfirmAction = "start" | "edit" | "cancel";
+
+type ContextProposalConfirmationActionItem = {
+	id: ContextProposalConfirmAction;
+	label: string;
+	description: string;
+};
+
+type ContextProposalConfirmationLayout = {
+	title: string;
+	intro: string;
+	proposalHeading: string;
+	proposalBody: string;
+	actionsHeading: string;
+	actions: ContextProposalConfirmationActionItem[];
+	footer: string;
+};
+
 type ContextProposalConfirmOptions = {
 	title: string;
 	nonInteractiveBehavior?: "accept" | "cancel";
 	editorPrompt?: string;
 };
 
+class StartupAnalystOverlay extends Container {
+	private readonly border: DynamicBorder;
+	private readonly title: Text;
+	private readonly body: Text;
+	private readonly footer: Text;
+	private lines: string[] = [];
+	onAbort?: () => void;
+
+	constructor(private readonly theme: any) {
+		super();
+		this.border = new DynamicBorder((s: string) => this.theme.fg("accent", s));
+		this.title = new Text("", 1, 0);
+		this.body = new Text("", 1, 1);
+		this.footer = new Text("", 1, 0);
+		this.addChild(this.border);
+		this.addChild(this.title);
+		this.addChild(this.body);
+		this.addChild(this.footer);
+		this.updateDisplay();
+	}
+
+	setLines(lines: string[]): void {
+		this.lines = [...lines];
+		this.updateDisplay();
+		this.invalidate();
+	}
+
+	private updateDisplay(): void {
+		this.title.setText(this.theme.fg("accent", this.theme.bold("/cook proposal analyst")));
+		this.body.setText(this.theme.fg("dim", this.lines.join("\n")));
+		this.footer.setText(this.theme.fg("muted", "Esc cancel • This analysis runs before /cook writes canonical workflow state"));
+	}
+
+	override handleInput(data: string): void {
+		if (data === "\u001b") {
+			this.onAbort?.();
+			return;
+		}
+		// Container does not implement handleInput; ignore all other keys.
+	}
+
+	override invalidate(): void {
+		super.invalidate();
+		this.updateDisplay();
+	}
+}
+
 const liveRoleActivityByRoot = new Map<string, LiveRoleActivity>();
 const LIVE_ROLE_WAITING_MS = 15_000;
 const LIVE_ROLE_STALLED_MS = 45_000;
@@ -420,6 +490,23 @@ function completionTestContextProposalEditText(): string | undefined {
 	return asString(process.env.PI_COMPLETION_CONTEXT_PROPOSAL_EDIT_TEXT);
 }
 
+function completionTestContextProposalUiActionOverride(): ContextProposalConfirmAction | undefined {
+	const raw = process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION?.trim().toLowerCase();
+	return raw === "start" || raw === "edit" || raw === "cancel" ? raw : undefined;
+}
+
+function completionTestContextProposalUiSnapshotPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH);
+}
+
+function shouldDisableContextProposalAnalyst(): boolean {
+	return process.env.PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST === "1";
+}
+
+function completionTestContextProposalAnalystOutput(): string | undefined {
+	return asString(process.env.PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT);
+}
+
 function isWorkflowDone(snapshot: CompletionStateSnapshot | undefined): boolean {
 	return asString(snapshot?.state?.continuation_policy) === "done";
 }
@@ -508,6 +595,335 @@ function uniqueProposalItems(items: string[]): string[] {
 	return result;
 }
 
+const MISSION_SCOPE_FILTER_STOPWORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"by",
+	"for",
+	"from",
+	"goal",
+	"goals",
+	"in",
+	"into",
+	"is",
+	"it",
+	"its",
+	"mission",
+	"of",
+	"on",
+	"or",
+	"scope",
+	"that",
+	"the",
+	"their",
+	"this",
+	"to",
+	"using",
+	"with",
+	"workflow",
+]);
+
+function missionScopeFilterTokens(text: string): string[] {
+	const normalized = normalizeProposalLine(text).toLowerCase();
+	const tokens = normalized.match(/[\p{L}\p{N}]+/gu) ?? [];
+	return tokens.filter((token) => {
+		if (/^[\p{Script=Han}]+$/u.test(token)) return token.length >= 2;
+		if (token.length < 2) return false;
+		return !MISSION_SCOPE_FILTER_STOPWORDS.has(token);
+	});
+}
+
+function isSessionScopeItemMissionRelevant(item: string, mission: string): boolean {
+	const normalizedItem = normalizeProposalLine(item).toLowerCase();
+	const normalizedMission = normalizeMissionAnchorText(mission).toLowerCase();
+	if (!normalizedItem || !normalizedMission) return true;
+	if (normalizedItem.includes(normalizedMission) || normalizedMission.includes(normalizedItem)) return true;
+	const itemTokens = [...new Set(missionScopeFilterTokens(normalizedItem))];
+	const missionTokens = new Set(missionScopeFilterTokens(normalizedMission));
+	if (itemTokens.length === 0 || missionTokens.size === 0) return true;
+	const overlap = itemTokens.filter((token) => missionTokens.has(token));
+	if (overlap.length >= 2) return true;
+	return overlap.some((token) => token.length >= 6 || /[\p{Script=Han}]/u.test(token));
+}
+
+const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
+	"You analyze recent /cook startup discussion and return a strict JSON object.",
+	"Do not emit markdown, code fences, or commentary.",
+	"Return exactly one JSON object with keys: mission, scope, constraints, acceptance, confidence, possible_noise.",
+	"mission must be a concise implementation mission anchor sentence.",
+	"scope must contain only work items that directly support the mission.",
+	"constraints must contain guardrails or non-goals explicitly stated or strongly implied by the discussion.",
+	"acceptance must contain verifiable outcomes explicitly stated or strongly implied by the discussion.",
+	"possible_noise should list discussion points that look stale, weakly related, or unsafe to promote into scope.",
+	"When an explicit goal is provided, keep the mission anchored to that goal instead of replacing it with a broader or different mission.",
+	"When discussion is insufficient, prefer empty arrays and a low confidence value over invention.",
+].join(" ");
+
+function collectRecentDiscussionEntries(ctx: { sessionManager: any }, limit = 8): RecentDiscussionEntry[] {
+	let branch: any[] = [];
+	try {
+		branch = ctx.sessionManager?.getBranch?.() ?? [];
+	} catch (error) {
+		if (isStaleContextError(error)) return [];
+		throw error;
+	}
+	const entries: RecentDiscussionEntry[] = [];
+	for (let index = branch.length - 1; index >= 0; index -= 1) {
+		const entry = branch[index];
+		if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) continue;
+		const message = entry.message as JsonRecord;
+		let text = "";
+		let role: RecentDiscussionEntry["role"] | undefined;
+		const messageRole = asString(message.role);
+		if (messageRole === "user" || messageRole === "assistant" || messageRole === "custom") {
+			text = extractTextFromMessageContent(message.content);
+			role = messageRole;
+		} else if (messageRole === "branchSummary" || messageRole === "compactionSummary") {
+			text = asString(message.summary) ?? "";
+			role = "summary";
+		}
+		if (!text || !role) continue;
+		const trimmed = text.trim();
+		if (!trimmed || /^\/(?:cook|complete)\b/i.test(trimmed)) continue;
+		entries.push({ role, text: trimmed });
+		if (entries.length >= limit) break;
+	}
+	return entries;
+}
+
+function serializeRecentDiscussionEntries(entries: RecentDiscussionEntry[]): string {
+	return entries
+		.slice()
+		.reverse()
+		.map((entry, index) => `[${index + 1}] ${entry.role.toUpperCase()}\n${entry.text}`)
+		.join("\n\n");
+}
+
+function extractJsonObjectFromText(text: string): string | undefined {
+	const trimmed = text.trim();
+	if (!trimmed) return undefined;
+	const unfenced = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+	if (unfenced.startsWith("{") && unfenced.endsWith("}")) return unfenced;
+	const start = unfenced.indexOf("{");
+	const end = unfenced.lastIndexOf("}");
+	if (start < 0 || end <= start) return undefined;
+	return unfenced.slice(start, end + 1);
+}
+
+function parseContextProposalAnalystOutput(
+	raw: string,
+	projectName: string,
+	explicitGoal?: string,
+): ContextProposal | undefined {
+	const jsonText = extractJsonObjectFromText(raw);
+	if (!jsonText) return undefined;
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(jsonText);
+	} catch {
+		return undefined;
+	}
+	if (!isRecord(parsed)) return undefined;
+	const explicit = explicitGoal ? parseContextProposal(explicitGoal, projectName) : undefined;
+	const missionSource = explicit?.mission ?? explicitGoal ?? asString(parsed.mission);
+	if (!missionSource) return undefined;
+	const assessment = assessMissionAnchor(missionSource, projectName);
+	const normalizedMission = normalizeMissionAnchorText(missionSource);
+	if (!normalizedMission || isWeakMissionAnchor(normalizedMission)) return undefined;
+	const mission = assessment.derived;
+	const scope = uniqueProposalItems(asStringArray(parsed.scope));
+	const constraints = uniqueProposalItems(asStringArray(parsed.constraints));
+	const acceptance = uniqueProposalItems(asStringArray(parsed.acceptance));
+	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
+	return {
+		mission,
+		scope,
+		constraints,
+		acceptance,
+		goalText,
+		basisPreview: raw.replace(/\s+/g, " ").trim(),
+		source: "analyst",
+	};
+}
+
+function contextProposalAnalystModelArg(model: unknown): string | undefined {
+	if (!isRecord(model)) return undefined;
+	const provider = asString(model.provider);
+	const id = asString(model.id);
+	return provider && id ? `${provider}/${id}` : undefined;
+}
+
+function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[], explicitGoal?: string): string {
+	const discussion = serializeRecentDiscussionEntries(recentEntries);
+	return [
+		`Project: ${projectName}`,
+		explicitGoal
+			? `Explicit goal (keep this mission anchor):\n${explicitGoal}`
+			: "Explicit goal: none provided; infer the current mission from the discussion.",
+		"",
+		"Recent discussion:",
+		discussion,
+	].join("\n");
+}
+
+function contextProposalAnalystProgressLines(activity: LiveRoleActivity): string[] {
+	return [
+		...buildInlineRunningLines({
+			role: activity.role,
+			startedAt: activity.startedAt,
+			updatedAt: activity.updatedAt,
+			currentAction: activity.currentAction,
+			toolActivity: activity.toolActivity,
+			toolRecentActivity: activity.toolRecentActivity,
+			recentActivity: activity.recentActivity,
+			assistantSummary: activity.assistantSummary,
+			progress: activity.progress,
+			rationale: activity.rationale,
+			nextStep: activity.nextStep,
+			verifying: activity.verifying,
+			stateDeltas: activity.stateDeltas,
+		}),
+		"",
+		"This step only prepares a proposal for confirmation.",
+	];
+}
+
+async function runContextProposalAnalystSubprocess(
+	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any },
+	projectName: string,
+	recentEntries: RecentDiscussionEntry[],
+	explicitGoal?: string,
+): Promise<string | undefined> {
+	const modelArg = contextProposalAnalystModelArg(ctx.model);
+	if (!modelArg) return undefined;
+	const cwd = getCtxCwd(ctx);
+	const runCwd = findCompletionRoot(cwd) ?? findRepoRoot(cwd) ?? cwd;
+	const rootKey = completionRootKey(undefined, cwd);
+	const prompt = buildContextProposalAnalystPrompt(projectName, recentEntries, explicitGoal);
+	const systemPromptTemp = await writeTempFile("pi-cook-proposal-analyst-", CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT);
+	const analystRole = "cook-proposal-analyst";
+	const args: string[] = ["--mode", "json", "-p", "--no-session", "--append-system-prompt", systemPromptTemp.filePath, "--model", modelArg, prompt];
+	const invocation = getPiInvocation(args);
+	const liveActivity = createLiveRoleActivity(analystRole);
+	liveActivity.progress = "Analyzing recent discussion";
+	liveActivity.currentAction = "Reading recent discussion and preparing a startup proposal";
+	liveActivity.assistantSummary = liveActivity.progress;
+	liveActivity.recentActivity = pushRecentActivity(liveActivity.recentActivity, `assistant: ${liveActivity.progress}`);
+	const messages: RoleMessage[] = [];
+	let stderr = "";
+	let overlay: StartupAnalystOverlay | undefined;
+	let finishOverlay: ((value: string | undefined) => void) | undefined;
+	let overlaySettled = false;
+	const settleOverlay = (value: string | undefined) => {
+		if (overlaySettled) return;
+		overlaySettled = true;
+		finishOverlay?.(value);
+	};
+	const updateActivity = (fresh = false) => {
+		if (fresh) liveActivity.updatedAt = nowMs();
+		liveRoleActivityByRoot.set(rootKey, cloneLiveRoleActivity(liveActivity, { status: "running" }));
+		void refreshStatus(ctx);
+		overlay?.setLines(contextProposalAnalystProgressLines(liveActivity));
+	};
+	const heartbeat = setInterval(() => updateActivity(false), LIVE_ROLE_HEARTBEAT_MS);
+	const run = async (): Promise<string | undefined> => {
+		try {
+			updateActivity(true);
+			const output = await new Promise<string | undefined>((resolve) => {
+				const proc = spawn(invocation.command, invocation.args, {
+					cwd: runCwd,
+					env: process.env,
+					stdio: ["ignore", "pipe", "pipe"],
+					shell: false,
+				});
+				let buffer = "";
+				const processLine = (line: string) => {
+					if (!line.trim()) return;
+					try {
+						const event = JSON.parse(line) as JsonRecord;
+						if (applyLiveRoleEvent(liveActivity, event, messages)) updateActivity(true);
+					} catch {
+						// ignore malformed lines
+					}
+				};
+				proc.stdout.on("data", (chunk) => {
+					buffer += chunk.toString();
+					const lines = buffer.split("\n");
+					buffer = lines.pop() ?? "";
+					for (const line of lines) processLine(line);
+				});
+				proc.stderr.on("data", (chunk) => {
+					stderr += chunk.toString();
+				});
+				proc.on("close", (code) => {
+					if (buffer.trim()) processLine(buffer);
+					resolve(code === 0 ? liveActivity.lastAssistantText?.trim() || undefined : undefined);
+				});
+				proc.on("error", () => resolve(undefined));
+				if (overlay) {
+					overlay.onAbort = () => {
+						proc.kill("SIGTERM");
+						resolve(undefined);
+					};
+				}
+			});
+			liveRoleActivityByRoot.set(rootKey, cloneLiveRoleActivity(liveActivity, { status: output ? "ok" : "error" }));
+			await refreshStatus(ctx);
+			return output;
+		} finally {
+			clearInterval(heartbeat);
+			setTimeout(() => {
+				const current = liveRoleActivityByRoot.get(rootKey);
+				if (current && current.role === analystRole && current.status !== "running") {
+					liveRoleActivityByRoot.delete(rootKey);
+					void refreshStatus(ctx);
+				}
+			}, 10_000);
+			await fsp.rm(systemPromptTemp.dir, { recursive: true, force: true });
+		}
+	};
+	if (getCtxHasUI(ctx)) {
+		const ui = getCtxUi(ctx);
+		if (ui) {
+			return await ui.custom<string | undefined>((_tui, theme, _kb, done) => {
+				finishOverlay = done;
+				overlay = new StartupAnalystOverlay(theme);
+				overlay.setLines(contextProposalAnalystProgressLines(liveActivity));
+				run().then(settleOverlay).catch(() => settleOverlay(undefined));
+				return overlay;
+			});
+		}
+	}
+	return await run();
+}
+
+async function analyzeContextProposalWithAgent(
+	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any; modelRegistry?: any },
+	projectName: string,
+	recentEntries: RecentDiscussionEntry[],
+	explicitGoal?: string,
+): Promise<ContextProposal | undefined> {
+	if (shouldDisableContextProposalAnalyst()) return undefined;
+	const testOutput = completionTestContextProposalAnalystOutput();
+	if (testOutput) {
+		return parseContextProposalAnalystOutput(testOutput, projectName, explicitGoal);
+	}
+	if (recentEntries.length === 0) return undefined;
+	try {
+		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries, explicitGoal);
+		if (!raw) return undefined;
+		return parseContextProposalAnalystOutput(raw, projectName, explicitGoal);
+	} catch (error) {
+		console.warn("[completion] context proposal analyst failed", error);
+		return undefined;
+	}
+}
+
 function buildContextProposalGoalText(proposal: {
 	mission: string;
 	scope: string[];
@@ -547,27 +963,141 @@ function buildContextProposalDisplayText(proposal: ContextProposal): string {
 	return lines.join("\n");
 }
 
-function buildContextProposalSelectionText(proposal: ContextProposal): string {
+function buildContextProposalConfirmationActions(): ContextProposalConfirmationActionItem[] {
 	return [
-		"I found a likely implementation plan in the recent discussion.",
-		"Confirm it before /cook writes canonical workflow state.",
-		"",
-		buildContextProposalDisplayText(proposal),
-		"",
-		"Start the workflow with this proposal.",
-	].join("\n");
+		{
+			id: "start",
+			label: "Start",
+			description: "Accept this proposal and let /cook write or refocus canonical workflow state.",
+		},
+		{
+			id: "edit",
+			label: "Edit",
+			description: "Open the existing proposal editor before starting the workflow.",
+		},
+		{
+			id: "cancel",
+			label: "Cancel",
+			description: "Exit without changing canonical workflow state.",
+		},
+	];
 }
 
-function buildContextProposalEditChoiceText(): string {
-	return [
-		"Edit this proposal before starting.",
-		"",
-		"Use this when the mission is right but the scope, constraints, or acceptance details need cleanup.",
-	].join("\n");
+function buildContextProposalConfirmationLayout(
+	title: string,
+	proposal: ContextProposal,
+): ContextProposalConfirmationLayout {
+	return {
+		title,
+		intro: "Review the proposed mission, scope, constraints, and acceptance details before /cook writes canonical workflow state.",
+		proposalHeading: "Proposed workflow",
+		proposalBody: buildContextProposalDisplayText(proposal),
+		actionsHeading: "Actions",
+		actions: buildContextProposalConfirmationActions(),
+		footer: "↑↓ navigate • enter select • esc cancel",
+	};
+}
+
+function maybeWriteContextProposalConfirmationSnapshot(layout: ContextProposalConfirmationLayout): void {
+	const snapshotPath = completionTestContextProposalUiSnapshotPath();
+	if (!snapshotPath) return;
+	try {
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		fs.writeFileSync(snapshotPath, `${JSON.stringify(layout, null, 2)}\n`, "utf8");
+	} catch {
+		// ignore malformed or unwritable test snapshot paths
+	}
+}
+
+function buildContextProposalConfirmationSelectItems(layout: ContextProposalConfirmationLayout): SelectItem[] {
+	return layout.actions.map((action) => ({
+		value: action.id,
+		label: action.label,
+		description: action.description,
+	}));
+}
+
+async function promptContextProposalConfirmationAction(
+	ui: any,
+	layout: ContextProposalConfirmationLayout,
+): Promise<ContextProposalConfirmAction | undefined> {
+	const items = buildContextProposalConfirmationSelectItems(layout);
+	return await ui.custom<ContextProposalConfirmAction | undefined>((tui: any, theme: any, _kb: any, done: any) => {
+		const container = new Container();
+		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+		container.addChild(new Text(theme.fg("accent", theme.bold(layout.title)), 1, 0));
+		container.addChild(new Text(theme.fg("dim", layout.intro), 1, 0));
+		container.addChild(new Text("", 0, 0));
+		container.addChild(new Text(theme.fg("accent", theme.bold(layout.proposalHeading)), 1, 0));
+		container.addChild(new Text(layout.proposalBody, 1, 0));
+		container.addChild(new Text("", 0, 0));
+		container.addChild(new Text(theme.fg("accent", theme.bold(layout.actionsHeading)), 1, 0));
+		const selectList = new SelectList(items, items.length, {
+			selectedPrefix: (text) => theme.fg("accent", text),
+			selectedText: (text) => theme.fg("accent", text),
+			description: (text) => theme.fg("muted", text),
+			scrollInfo: (text) => theme.fg("dim", text),
+			noMatch: (text) => theme.fg("warning", text),
+		});
+		selectList.onSelect = (item) => done(item.value as ContextProposalConfirmAction);
+		selectList.onCancel = () => done(undefined);
+		container.addChild(selectList);
+		container.addChild(new Text(theme.fg("dim", layout.footer), 1, 0));
+		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+		return {
+			render: (width: number) => container.render(width),
+			invalidate: () => container.invalidate(),
+			handleInput: (data: string) => {
+				if (matchesKey(data, "escape")) {
+					done(undefined);
+					return;
+				}
+				selectList.handleInput(data);
+				tui.requestRender();
+			},
+		};
+	});
 }
 
-function buildContextProposalCancelChoiceText(): string {
-	return ["Cancel", "", "Do not start a workflow yet."].join("\n");
+async function resolveEditedContextProposalDecision(
+	ctx: { hasUI: boolean; ui: any },
+	projectName: string,
+	editedText: string,
+	confirmMissionWhenNeeded: boolean,
+): Promise<ContextProposalDecision | undefined> {
+	if (!editedText.trim()) return undefined;
+	const editedProposal = parseContextProposal(editedText, projectName);
+	if (editedProposal) return { missionAnchor: editedProposal.mission, goalText: editedProposal.goalText };
+	const assessment = assessMissionAnchor(editedText, projectName);
+	if (!confirmMissionWhenNeeded) {
+		return { missionAnchor: assessment.derived, goalText: editedText.trim() };
+	}
+	const missionAnchor = await confirmMissionAnchor(ctx, assessment);
+	if (!missionAnchor) return undefined;
+	return { missionAnchor, goalText: editedText.trim() };
+}
+
+async function resolveContextProposalConfirmationAction(
+	ctx: { hasUI: boolean; ui: any },
+	proposal: ContextProposal,
+	projectName: string,
+	options: ContextProposalConfirmOptions,
+	action: ContextProposalConfirmAction,
+	editedTextOverride?: string,
+): Promise<ContextProposalDecision | undefined> {
+	if (action === "cancel") return undefined;
+	if (action === "start") {
+		return { missionAnchor: proposal.mission, goalText: proposal.goalText };
+	}
+	const editedText =
+		editedTextOverride ??
+		(await getCtxUi(ctx)?.editor(
+			options.editorPrompt ?? `${options.title}\n\nEdit the proposed mission, scope, constraints, and acceptance details below.`,
+			buildContextProposalEditorText(proposal),
+		));
+	if (!editedText?.trim()) return undefined;
+	return await resolveEditedContextProposalDecision(ctx, projectName, editedText, editedTextOverride === undefined);
 }
 
 function buildContextProposalEditorText(proposal: ContextProposal): string {
@@ -680,53 +1210,28 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 	};
 }
 
-function extractContextProposalFromSession(ctx: { sessionManager: any }, projectName: string): ContextProposal | undefined {
-	let branch: any[] = [];
-	try {
-		branch = ctx.sessionManager?.getBranch?.() ?? [];
-	} catch (error) {
-		if (isStaleContextError(error)) return undefined;
-		throw error;
-	}
-	const candidates: string[] = [];
-	for (let index = branch.length - 1; index >= 0; index -= 1) {
-		const entry = branch[index];
-		if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) continue;
-		const message = entry.message as JsonRecord;
-		let text = "";
-		const role = asString(message.role);
-		if (role === "user" || role === "assistant" || role === "custom") {
-			text = extractTextFromMessageContent(message.content);
-		} else if (role === "branchSummary" || role === "compactionSummary") {
-			text = asString(message.summary) ?? "";
-		}
-		if (!text) continue;
-		const trimmed = text.trim();
-		if (!trimmed || /^\/(?:cook|complete)\b/i.test(trimmed)) continue;
-		candidates.push(trimmed);
-	}
-	for (const candidate of candidates) {
-		const parsed = parseContextProposal(candidate, projectName);
-		if (parsed) return parsed;
-	}
-	if (candidates.length > 1) {
-		const combined = candidates.slice(0, 4).reverse().join("\n\n");
-		return parseContextProposal(combined, projectName);
-	}
-	return undefined;
+async function extractContextProposalFromSession(
+	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
+	projectName: string,
+	explicitGoal?: string,
+): Promise<ContextProposal | undefined> {
+	const recentEntries = collectRecentDiscussionEntries(ctx);
+	return await analyzeContextProposalWithAgent(ctx, projectName, recentEntries, explicitGoal);
 }
 
-function buildGoalAnchoredContextProposal(
-	ctx: { sessionManager: any },
+async function buildGoalAnchoredContextProposal(
+	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	goal: string,
 	projectName: string,
-): ContextProposal {
+): Promise<ContextProposal> {
 	const explicit = parseContextProposal(goal, projectName);
-	const sessionProposal = extractContextProposalFromSession(ctx, projectName);
+	const sessionProposal = await extractContextProposalFromSession(ctx, projectName, goal);
 	const missionSource = explicit?.mission ?? goal;
 	const assessment = assessMissionAnchor(missionSource, projectName);
 	const mission = assessment.derived;
-	const scope = uniqueProposalItems([...(explicit?.scope ?? []), ...(sessionProposal?.scope ?? [])]);
+	const explicitScope = explicit?.scope ?? [];
+	const sessionScope = (sessionProposal?.scope ?? []).filter((item) => isSessionScopeItemMissionRelevant(item, mission));
+	const scope = uniqueProposalItems([...explicitScope, ...sessionScope]);
 	const constraints = uniqueProposalItems([...(explicit?.constraints ?? []), ...(sessionProposal?.constraints ?? [])]);
 	const acceptance = uniqueProposalItems([...(explicit?.acceptance ?? []), ...(sessionProposal?.acceptance ?? [])]);
 	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
@@ -737,7 +1242,7 @@ function buildGoalAnchoredContextProposal(
 		acceptance,
 		goalText,
 		basisPreview: sessionProposal?.basisPreview ?? explicit?.basisPreview ?? goal,
-		source: "session",
+		source: sessionProposal?.source ?? "session",
 	};
 }
 
@@ -755,10 +1260,20 @@ async function confirmContextProposal(
 	if (actionOverride === "edit") {
 		const editedText = completionTestContextProposalEditText();
 		if (!editedText) return undefined;
-		const editedProposal = parseContextProposal(editedText, projectName);
-		if (editedProposal) return { missionAnchor: editedProposal.mission, goalText: editedProposal.goalText };
-		const assessment = assessMissionAnchor(editedText, projectName);
-		return { missionAnchor: assessment.derived, goalText: editedText.trim() };
+		return await resolveEditedContextProposalDecision(ctx, projectName, editedText, false);
+	}
+	const layout = buildContextProposalConfirmationLayout(options.title, proposal);
+	maybeWriteContextProposalConfirmationSnapshot(layout);
+	const uiActionOverride = completionTestContextProposalUiActionOverride();
+	if (uiActionOverride) {
+		return await resolveContextProposalConfirmationAction(
+			ctx,
+			proposal,
+			projectName,
+			options,
+			uiActionOverride,
+			uiActionOverride === "edit" ? completionTestContextProposalEditText() : undefined,
+		);
 	}
 	if (!getCtxHasUI(ctx)) {
 		return options.nonInteractiveBehavior === "accept"
@@ -771,25 +1286,9 @@ async function confirmContextProposal(
 			? { missionAnchor: proposal.mission, goalText: proposal.goalText }
 			: undefined;
 	}
-	const useChoice = buildContextProposalSelectionText(proposal);
-	const editChoice = buildContextProposalEditChoiceText();
-	const cancelChoice = buildContextProposalCancelChoiceText();
-	const choice = await ui.select(options.title, [useChoice, editChoice, cancelChoice]);
-	if (!choice || choice === cancelChoice) return undefined;
-	if (choice === editChoice) {
-		const editedText = await ui.editor(
-			options.editorPrompt ?? `${options.title}\n\nEdit the proposed mission, scope, constraints, and acceptance details below.`,
-			buildContextProposalEditorText(proposal),
-		);
-		if (!editedText?.trim()) return undefined;
-		const editedProposal = parseContextProposal(editedText, projectName);
-		if (editedProposal) return { missionAnchor: editedProposal.mission, goalText: editedProposal.goalText };
-		const assessment = assessMissionAnchor(editedText, projectName);
-		const missionAnchor = await confirmMissionAnchor(ctx, assessment);
-		if (!missionAnchor) return undefined;
-		return { missionAnchor, goalText: editedText.trim() };
-	}
-	return { missionAnchor: proposal.mission, goalText: proposal.goalText };
+	const choice = await promptContextProposalConfirmationAction(ui, layout);
+	if (!choice) return undefined;
+	return await resolveContextProposalConfirmationAction(ctx, proposal, projectName, options, choice);
 }
 
 function currentMissionAnchor(snapshot: CompletionStateSnapshot): string {
@@ -2422,11 +2921,11 @@ export default function completionExtension(pi: ExtensionAPI) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
 				if (!goal) {
-					const proposal = extractContextProposalFromSession(ctx, projectName);
+					const proposal = await extractContextProposalFromSession(ctx, projectName);
 					if (!proposal) {
 						emitCommandText(
 							ctx,
-							"Usage: /cook <goal> (or finish shaping the plan in discussion, then rerun /cook to confirm the proposed workflow)",
+							"Usage: /cook <goal> (discussion-only startup needs proposal analyst output; otherwise pass an explicit goal)",
 							"error",
 						);
 						return;
@@ -2443,7 +2942,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 					goal = decision.goalText;
 					kickoffMissionAnchor = decision.missionAnchor;
 				} else {
-					const proposal = buildGoalAnchoredContextProposal(ctx, goal, projectName);
+					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
 					const decision = await confirmContextProposal(ctx, proposal, projectName, {
 						title: "Start a completion workflow from this goal?",
 						nonInteractiveBehavior: "accept",
@@ -2472,11 +2971,11 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!goal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = extractContextProposalFromSession(ctx, projectName);
+					const proposal = await extractContextProposalFromSession(ctx, projectName);
 					if (!proposal) {
 						emitCommandText(
 							ctx,
-							"The previous completion workflow is already done. Shape the next plan in discussion or provide a new goal, then rerun /cook to start the next round.",
+							"The previous completion workflow is already done. Provide /cook <goal>, or rerun /cook when the proposal analyst can summarize the next round from discussion.",
 							"info",
 						);
 						return;
@@ -2512,7 +3011,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (hadSnapshot && explicitGoal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = buildGoalAnchoredContextProposal(ctx, goal, projectName);
+					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
 					const decision = await confirmContextProposal(ctx, proposal, projectName, {
 						title: "Start the next workflow round from this goal?",
 						nonInteractiveBehavior: "accept",
@@ -2539,7 +3038,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 					kickoffMissionAnchor = decision.currentMissionAnchor;
 					if (decision.action === "refocus") {
 						const projectName = path.basename(snapshot.files.root);
-						const proposal = buildGoalAnchoredContextProposal(ctx, goal, projectName);
+						const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
 						const proposalDecision = await confirmContextProposal(ctx, proposal, projectName, {
 							title: "Start the replacement workflow from this goal?",
 							nonInteractiveBehavior: "accept",