@linimin/pi-letscook 0.1.26 → 0.1.28

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.28
+
+### Changed
+
+- added model-assisted `/cook` startup proposal analysis for natural recent discussion with a live `/cook proposal analyst` progress overlay, removed the built-in discussion-parser fallback for discussion-only startup, and preserved explicit-goal mission anchoring even when analyst output is unavailable
+- replaced the crowded built-in `/cook` startup proposal selector presentation with a custom confirmation UI that separates proposal content from explicit Start, Edit, and Cancel actions
+- fixed `/cook proposal analyst` overlay input handling and improved proposal body readability in the confirmation UI
+
+## 0.1.27
+
+### Changed
+
+- added package metadata for npm and pi.dev discovery, fixed README publishing links for npm rendering, and refined install and workflow guidance after the `v0.1.26` tag
+
 ## 0.1.26
 
 ### Changed

package/README.md

@@ -6,7 +6,8 @@ Pi package for long-running coding workflows with canonical repo-local `.agent/*
 
 - `/cook` as the single workflow command
 - `/cook <goal>` to bootstrap or continue with an explicit goal, enriched by recent discussion before canonical state is written
-- `/cook` with no goal to resume an active canonical `.agent/**` workflow, or propose a new round from recent discussion when no active workflow is running
+- `/cook` with no goal to resume an active canonical `.agent/**` workflow, or propose a new round from recent discussion through the proposal analyst when no active workflow is running
+- model-assisted startup proposal analysis for natural recent discussion, with a live `/cook proposal analyst` overlay; if that analysis is unavailable, use `/cook <goal>` instead of a built-in discussion parser fallback
 - `/cook <new goal>` on an active workflow asks whether to continue the current mission or abandon it for a replacement workflow; on a completed workflow it starts the next round from the new goal instead of reopening continue/refocus choices
 - no duplicate prompt-template aliases for core workflow commands
 - role-based isolated subprocess execution via `completion_role`
@@ -89,9 +90,9 @@ After install, run `/reload` in pi. For this package, it is safest to reload whe
 
 | Repo state | `/cook` | `/cook <goal>` |
 |---|---|---|
-| No canonical workflow yet | Proposes a startup plan from recent discussion, then asks for confirmation | Builds a startup proposal anchored on the explicit goal, enriches it from recent discussion, then asks for confirmation |
+| No canonical workflow yet | Proposes a startup plan from recent discussion when the proposal analyst can summarize it, then asks for confirmation | Builds a startup proposal anchored on the explicit goal, enriches it from recent discussion when analyst output is available, then asks for confirmation |
 | Active workflow exists | Resumes the active workflow from canonical `.agent/**` state | Asks whether to continue the current workflow or replace it with a new one |
-| Previous workflow is already `done` | Proposes the next workflow round from recent discussion, then asks for confirmation | Starts the next workflow round from the explicit goal, using recent discussion only as supplemental proposal context |
+| Previous workflow is already `done` | Proposes the next workflow round from recent discussion when the proposal analyst can summarize it, then asks for confirmation | Starts the next workflow round from the explicit goal, using recent discussion only as supplemental proposal context when analyst output is available |
 
 ### One-step start
 
@@ -101,7 +102,7 @@ After install, run `/reload` in pi. For this package, it is safest to reload whe
 
 This bootstraps `.agent/**` if missing, derives a clean initial `MISSION ANCHOR`, builds a startup proposal, lets you confirm or edit it, re-grounds canonical state, creates a slice plan, and drives the workflow.
 
-When you pass an explicit goal, that goal stays the mission anchor. Recent discussion is only used to fill in extra scope, constraints, and acceptance details before canonical state is written.
+When a model is available, `/cook` first asks it to summarize the recent natural-language discussion into a structured proposal and shows a live `/cook proposal analyst` progress overlay while that analysis is running. Discussion-only startup now relies on that analyst path only; if analyst output is unavailable, use `/cook <goal>` instead of expecting a built-in rule-based parser fallback. When you pass an explicit goal, that goal still stays the mission anchor. Recent discussion is only used to fill in extra scope, constraints, and acceptance details before canonical state is written when analyst output is available.
 
 ### Resume later
 
@@ -138,7 +139,7 @@ If the previous workflow is already `done`, `/cook <goal>` starts the next workf
 /cook
 ```
 
-If the previous workflow is already `done`, `/cook` with no goal tries to infer the next plan from recent discussion, asks you to confirm it, and then starts the next workflow round from refreshed canonical state.
+If the previous workflow is already `done`, `/cook` with no goal tries to infer the next plan from recent discussion through the proposal analyst, asks you to confirm it, and then starts the next workflow round from refreshed canonical state. If analyst output is unavailable, provide an explicit goal with `/cook <goal>` instead.
 
 ## Canonical repo files
 
@@ -209,7 +210,7 @@ npm run release-check
 
 `npm run release-check` is the broader packaged-release verifier. It reruns the smoke, refocus, and context-proposal checks, includes the deterministic observability regression coverage, and finishes with `npm pack --dry-run`.
 
-See [PUBLISHING.md](./PUBLISHING.md) for GitHub and npm release steps.
+See [PUBLISHING.md](https://github.com/linimin/pi-letscook/blob/main/PUBLISHING.md) for GitHub and npm release steps.
 
 ## Notes
 

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",

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Pi package for long-running completion workflows with canonical .agent state, role-based subagents, continuity, and verification helpers.",
   "license": "MIT",
   "private": false,
+  "author": "linimin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/linimin/pi-letscook.git"
+  },
+  "homepage": "https://github.com/linimin/pi-letscook#readme",
+  "bugs": {
+    "url": "https://github.com/linimin/pi-letscook/issues"
+  },
   "keywords": ["pi-package", "pi", "workflow", "completion", "agent", "subagent"],
   "files": [
     "extensions",

package/scripts/context-proposal-test.sh

@@ -101,12 +101,30 @@ mkdir -p "$ROOT"
 cd "$ROOT"
 git init -q
 
-# No workflow yet: /cook with no goal should infer from recent discussion.
+# No workflow yet: /cook with no goal should not bootstrap from discussion alone when analyst output is unavailable.
+SESSION_ZERO="$TMPDIR/session-zero.jsonl"
+DISCUSSION_ZERO=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\n- Suppress the widget while a completion role is active.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\n- Keep observability regression coverage truthful.'
+write_session "$SESSION_ZERO" "$ROOT" "$DISCUSSION_ZERO"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-no-analyst.out 2>/tmp/pi-completion-context-proposal-no-analyst.err
+
+python3 - <<'PY'
+from pathlib import Path
+
+assert not Path('.agent').exists(), '/cook should not bootstrap canonical state from discussion alone without analyst output'
+PY
+
+# No workflow yet: /cook with no goal should infer from recent discussion through analyst output.
 SESSION_ONE="$TMPDIR/session-one.jsonl"
-DISCUSSION_ONE=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\n- Suppress the widget while a completion role is active.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\n- Keep observability regression coverage truthful.'
+DISCUSSION_ONE="$DISCUSSION_ZERO"
+ANALYST_OUTPUT_ONE='{"mission":"Remove the completion status line while keeping the completion widget.","scope":["Keep the non-running completion widget.","Suppress the widget while a completion role is active."],"constraints":["Do not reintroduce any other completion status surface."],"acceptance":["Update README to match the shipped behavior.","Keep observability regression coverage truthful."],"confidence":0.94}'
 write_session "$SESSION_ONE" "$ROOT" "$DISCUSSION_ONE"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$ANALYST_OUTPUT_ONE" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$SESSION_ONE" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-bootstrap.out 2>/tmp/pi-completion-context-proposal-bootstrap.err
 
@@ -120,22 +138,24 @@ state = json.loads(Path('.agent/state.json').read_text())
 plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
 
-assert mission in mission_text, '.agent/mission.md did not record the context-derived mission anchor'
-assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after context-derived bootstrap'
-assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after context-derived bootstrap'
-assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after context-derived bootstrap'
-assert state['current_phase'] == 'reground', 'state.json current_phase should start at reground after context-derived bootstrap'
-assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should start at completion-regrounder after context-derived bootstrap'
+assert mission in mission_text, '.agent/mission.md did not record the analyst-derived mission anchor'
+assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after analyst-derived bootstrap'
+assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after analyst-derived bootstrap'
+assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after analyst-derived bootstrap'
+assert state['current_phase'] == 'reground', 'state.json current_phase should start at reground after analyst-derived bootstrap'
+assert state['next_mandatory_role'] == 'completion-regrounder', 'next_mandatory_role should start at completion-regrounder after analyst-derived bootstrap'
 PY
 
-# Completed workflow: /cook with no goal should infer the next round from recent discussion.
+# Completed workflow: /cook with no goal should infer the next round from recent discussion through analyst output.
 mark_done
 
 SESSION_TWO="$TMPDIR/session-two.jsonl"
 DISCUSSION_TWO=$'Mission: Ship the next workflow round for richer context-derived /cook startup.\nScope:\n- Start a new workflow round from recent discussion after the previous one is done.\n- Keep using canonical .agent state after confirmation.\nConstraints:\n- Do not resume the completed workflow when the new round is clearly different.\nAcceptance:\n- Reset canonical state back to reground for the new mission.\n- Preserve the tracked completion control-plane files.'
+ANALYST_OUTPUT_TWO='{"mission":"Ship the next workflow round for richer context-derived /cook startup.","scope":["Start a new workflow round from recent discussion after the previous one is done.","Keep using canonical .agent state after confirmation."],"constraints":["Do not resume the completed workflow when the new round is clearly different."],"acceptance":["Reset canonical state back to reground for the new mission.","Preserve the tracked completion control-plane files."],"confidence":0.93}'
 write_session "$SESSION_TWO" "$ROOT" "$DISCUSSION_TWO"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$ANALYST_OUTPUT_TWO" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$SESSION_TWO" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-next-round.out 2>/tmp/pi-completion-context-proposal-next-round.err
 
@@ -163,14 +183,15 @@ assert plan['plan_basis'] == 'user_refocus', 'plan_basis should reset to user_re
 assert active['status'] == 'idle', 'active-slice should reset to idle for the next workflow round'
 PY
 
-# Active workflow: /cook <goal> plus refocus should use the explicit goal as the mission anchor,
-# while still allowing recent discussion to enrich the proposal before confirmation.
+# Active workflow: /cook <goal> plus refocus should use the explicit goal as the mission anchor
+# even when analyst output is unavailable, without falling back to session-derived proposal parsing.
 SESSION_THREE="$TMPDIR/session-three.jsonl"
 DISCUSSION_THREE=$'Scope:\n- Preserve the richer proposal structure from discussion.\nConstraints:\n- Keep explicit goals as the mission anchor when they conflict with earlier text.\nAcceptance:\n- Refresh canonical state from the replacement mission.'
 write_session "$SESSION_THREE" "$ROOT" "$DISCUSSION_THREE"
 
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$SESSION_THREE" -e "$PKG_ROOT" -p "/cook Explicit replacement mission for the active workflow" >/tmp/pi-completion-context-proposal-active-goal.out 2>/tmp/pi-completion-context-proposal-active-goal.err
 
@@ -192,31 +213,37 @@ assert state['current_phase'] == 'reground', 'current_phase should reset to regr
 assert state['continuation_policy'] == 'continue', 'continuation_policy should stay continue after explicit-goal replacement'
 assert state['next_mandatory_role'] == 'completion-regrounder', 'next role should reset to completion-regrounder after explicit-goal replacement'
 assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'continuation_reason should record the explicit-goal replacement'
+assert 'Preserve the richer proposal structure from discussion.' not in state['continuation_reason'], 'session scope should not be merged when analyst output is unavailable'
+assert 'Keep explicit goals as the mission anchor when they conflict with earlier text.' not in state['continuation_reason'], 'session constraints should not be merged when analyst output is unavailable'
+assert 'Refresh canonical state from the replacement mission.' not in state['continuation_reason'], 'session acceptance should not be merged when analyst output is unavailable'
 assert plan['plan_basis'] == 'user_refocus', 'plan_basis should be user_refocus after explicit-goal replacement'
 assert active['status'] == 'idle', 'active slice should reset to idle after explicit-goal replacement'
 PY
 
 # Completed workflow again: /cook <goal> should start the next round directly from the explicit goal
-# without requiring existing-workflow continue/refocus confirmation.
+# even when analyst output is unavailable, without merging session-derived scope, constraints, or acceptance.
 mark_done
 
 SESSION_FOUR="$TMPDIR/session-four.jsonl"
-DISCUSSION_FOUR=$'Mission: This older discussion should not override the explicit next-round goal.\nScope:\n- Reuse discussion details only as supplemental proposal context.\nAcceptance:\n- Start the next round from the explicit goal.'
+DISCUSSION_FOUR=$'Scope:\n- Add session-only scope.\n- Restyle widget.\nConstraints:\n- Keep rules.\nAcceptance:\n- Add test.'
+EXPLICIT_GOAL_FOUR=$'Mission: Filter scope by mission.\nScope:\n- Keep explicit scope.'
 write_session "$SESSION_FOUR" "$ROOT" "$DISCUSSION_FOUR"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi --session "$SESSION_FOUR" -e "$PKG_ROOT" -p "/cook Explicit goal for the next completed-workflow round" >/tmp/pi-completion-context-proposal-done-goal.out 2>/tmp/pi-completion-context-proposal-done-goal.err
+pi --session "$SESSION_FOUR" -e "$PKG_ROOT" -p "/cook $EXPLICIT_GOAL_FOUR" >/tmp/pi-completion-context-proposal-done-goal.out 2>/tmp/pi-completion-context-proposal-done-goal.err
 
 python3 - <<'PY'
 import json
 from pathlib import Path
 
-mission = 'Explicit goal for the next completed-workflow round.'
+mission = 'Filter scope by mission.'
 mission_text = Path('.agent/mission.md').read_text()
 state = json.loads(Path('.agent/state.json').read_text())
 plan = json.loads(Path('.agent/plan.json').read_text())
 active = json.loads(Path('.agent/active-slice.json').read_text())
+continuation_reason = state['continuation_reason']
 
 assert mission in mission_text, '.agent/mission.md did not update to the explicit next-round mission anchor'
 assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after explicit-goal next-round start'
@@ -227,9 +254,146 @@ assert state['continuation_policy'] == 'continue', 'continuation_policy should r
 assert state['project_done'] is False, 'project_done should reset to false after explicit-goal next-round start'
 assert state['requires_reground'] is True, 'requires_reground should reset to true after explicit-goal next-round start'
 assert state['next_mandatory_role'] == 'completion-regrounder', 'next role should reset to completion-regrounder after explicit-goal next-round start'
-assert state['continuation_reason'].startswith('User refocused workflow via /cook:'), 'continuation_reason should record the explicit-goal next-round start'
+assert continuation_reason.startswith('User refocused workflow via /cook:'), 'continuation_reason should record the explicit-goal next-round start'
+assert 'Keep explicit scope.' in continuation_reason, 'explicit scope should remain in the explicit-goal proposal'
+assert 'Add session-only scope.' not in continuation_reason, 'session-derived scope should not be merged when analyst output is unavailable'
+assert 'Restyle widget.' not in continuation_reason, 'unrelated session-derived scope should not be merged when analyst output is unavailable'
+assert 'Keep rules.' not in continuation_reason, 'session-derived constraints should not merge when analyst output is unavailable'
+assert 'Add test.' not in continuation_reason, 'session-derived acceptance should not merge when analyst output is unavailable'
 assert plan['plan_basis'] == 'user_refocus', 'plan_basis should be user_refocus after explicit-goal next-round start'
 assert active['status'] == 'idle', 'active slice should reset to idle after explicit-goal next-round start'
 PY
 
+# Completed workflow again: /cook with no goal should be able to use model-assisted
+# analysis of natural discussion when discussion-only startup depends on analyst output.
+mark_done
+
+SESSION_FIVE="$TMPDIR/session-five.jsonl"
+DISCUSSION_FIVE=$'I do not want to rewrite the parser. The safer path is to let /cook analyze the discussion first, keep the user\'s explicit mission if they provided one, and ignore stale scope that drifted in from earlier turns. We should still prove it with a regression test before writing canonical state.'
+ANALYST_OUTPUT_FIVE='{"mission":"Use a proposal analyst to summarize natural discussion before /cook writes canonical state.","scope":["Keep explicit goals anchored.","Drop stale scope from earlier turns."],"constraints":["Do not rewrite the parser."],"acceptance":["Add a regression test."],"confidence":0.91,"possible_noise":["old unrelated scope"]}'
+write_session "$SESSION_FIVE" "$ROOT" "$DISCUSSION_FIVE"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$ANALYST_OUTPUT_FIVE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_FIVE" -e "$PKG_ROOT" -p "/cook" >/tmp/pi-completion-context-proposal-analyst.out 2>/tmp/pi-completion-context-proposal-analyst.err
+
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+mission = 'Use a proposal analyst to summarize natural discussion before /cook writes canonical state.'
+mission_text = Path('.agent/mission.md').read_text()
+state = json.loads(Path('.agent/state.json').read_text())
+plan = json.loads(Path('.agent/plan.json').read_text())
+active = json.loads(Path('.agent/active-slice.json').read_text())
+continuation_reason = state['continuation_reason']
+
+assert mission in mission_text, '.agent/mission.md did not record the analyst-derived mission anchor'
+assert state['mission_anchor'] == mission, 'state.json mission_anchor mismatch after analyst-derived bootstrap'
+assert plan['mission_anchor'] == mission, 'plan.json mission_anchor mismatch after analyst-derived bootstrap'
+assert active['mission_anchor'] == mission, 'active-slice.json mission_anchor mismatch after analyst-derived bootstrap'
+assert state['current_phase'] == 'reground', 'current_phase should reset to reground after analyst-derived bootstrap'
+assert state['next_mandatory_role'] == 'completion-regrounder', 'next role should reset to completion-regrounder after analyst-derived bootstrap'
+assert continuation_reason.startswith('User refocused workflow via /cook:'), 'continuation_reason should record the analyst-derived restart'
+assert 'Keep explicit goals anchored.' in continuation_reason, 'analyst-derived scope should be preserved'
+PY
+
+# Custom confirmation UI: start should render proposal content separately from explicit Start/Edit/Cancel actions.
+UI_ROOT_START="$TMPDIR/ui-root-start"
+mkdir -p "$UI_ROOT_START"
+cd "$UI_ROOT_START"
+git init -q
+
+UI_SESSION_START="$TMPDIR/ui-session-start.jsonl"
+UI_DISCUSSION_START=$'Mission: Replace the crowded selector with a clearer action layout.\nScope:\n- Separate proposal text from actions.\nConstraints:\n- Preserve Start/Edit/Cancel behavior.\nAcceptance:\n- Add regression coverage.'
+UI_ANALYST_OUTPUT_START='{"mission":"Replace the crowded selector with a clearer action layout.","scope":["Separate proposal text from actions."],"constraints":["Preserve Start/Edit/Cancel behavior."],"acceptance":["Add regression coverage."],"confidence":0.95}'
+UI_SNAPSHOT_START="$TMPDIR/context-proposal-ui-start.json"
+write_session "$UI_SESSION_START" "$UI_ROOT_START" "$UI_DISCUSSION_START"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION=start \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH="$UI_SNAPSHOT_START" \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$UI_ANALYST_OUTPUT_START" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$UI_SESSION_START" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ui-start.out" 2>"$TMPDIR/pi-completion-context-proposal-ui-start.err"
+
+python3 - "$UI_SNAPSHOT_START" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert snapshot['proposalHeading'] == 'Proposed workflow', 'custom confirmation snapshot should expose a dedicated proposal section'
+assert 'Mission\nReplace the crowded selector with a clearer action layout.' in snapshot['proposalBody'], 'proposal body should be captured separately from the action list'
+assert [action['id'] for action in snapshot['actions']] == ['start', 'edit', 'cancel'], 'custom confirmation actions should stay Start/Edit/Cancel'
+assert [action['label'] for action in snapshot['actions']] == ['Start', 'Edit', 'Cancel'], 'custom confirmation action labels should be concise'
+for action in snapshot['actions']:
+    assert 'Replace the crowded selector with a clearer action layout.' not in action['label'], 'proposal mission should not be embedded in action labels'
+    assert 'Separate proposal text from actions.' not in action['description'], 'proposal scope should not be embedded in action descriptions'
+assert state['mission_anchor'] == 'Replace the crowded selector with a clearer action layout.', 'start action should still accept the proposed mission'
+PY
+
+# Custom confirmation UI: edit should keep the existing editor/parsing flow when the action comes from the new layout.
+UI_ROOT_EDIT="$TMPDIR/ui-root-edit"
+mkdir -p "$UI_ROOT_EDIT"
+cd "$UI_ROOT_EDIT"
+git init -q
+
+UI_SESSION_EDIT="$TMPDIR/ui-session-edit.jsonl"
+UI_DISCUSSION_EDIT=$'Mission: Keep editing support in the custom confirmation UI.\nScope:\n- Preserve the proposal editor.\nConstraints:\n- Keep parsing structured proposal text.\nAcceptance:\n- Update the mission anchor after edit.'
+UI_ANALYST_OUTPUT_EDIT='{"mission":"Keep editing support in the custom confirmation UI.","scope":["Preserve the proposal editor."],"constraints":["Keep parsing structured proposal text."],"acceptance":["Update the mission anchor after edit."],"confidence":0.94}'
+UI_EDIT_TEXT=$'Mission: Edited mission from the custom confirmation UI.\nScope:\n- Preserve parsing after edit.\nConstraints:\n- Keep the shared confirmation flow.\nAcceptance:\n- Start the workflow from the edited proposal.'
+write_session "$UI_SESSION_EDIT" "$UI_ROOT_EDIT" "$UI_DISCUSSION_EDIT"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION=edit \
+PI_COMPLETION_CONTEXT_PROPOSAL_EDIT_TEXT="$UI_EDIT_TEXT" \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$UI_ANALYST_OUTPUT_EDIT" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$UI_SESSION_EDIT" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ui-edit.out" 2>"$TMPDIR/pi-completion-context-proposal-ui-edit.err"
+
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+state = json.loads(Path('.agent/state.json').read_text())
+plan = json.loads(Path('.agent/plan.json').read_text())
+active = json.loads(Path('.agent/active-slice.json').read_text())
+mission = 'Edited mission from the custom confirmation UI.'
+
+assert state['mission_anchor'] == mission, 'edit action should still route through the proposal parser and update state.json'
+assert plan['mission_anchor'] == mission, 'edit action should still route through the proposal parser and update plan.json'
+assert active['mission_anchor'] == mission, 'edit action should still route through the proposal parser and update active-slice.json'
+assert state['current_phase'] == 'reground', 'edit action should still bootstrap/reground the workflow'
+PY
+
+# Custom confirmation UI: cancel should exit without writing canonical state.
+UI_ROOT_CANCEL="$TMPDIR/ui-root-cancel"
+mkdir -p "$UI_ROOT_CANCEL"
+cd "$UI_ROOT_CANCEL"
+git init -q
+
+UI_SESSION_CANCEL="$TMPDIR/ui-session-cancel.jsonl"
+UI_DISCUSSION_CANCEL=$'Mission: Cancel from the custom confirmation UI without writing state.\nScope:\n- Show the proposal separately from the actions.\nConstraints:\n- Keep cancellation side-effect free.\nAcceptance:\n- Leave .agent absent after cancel.'
+UI_ANALYST_OUTPUT_CANCEL='{"mission":"Cancel from the custom confirmation UI without writing state.","scope":["Show the proposal separately from the actions."],"constraints":["Keep cancellation side-effect free."],"acceptance":["Leave .agent absent after cancel."],"confidence":0.92}'
+UI_SNAPSHOT_CANCEL="$TMPDIR/context-proposal-ui-cancel.json"
+write_session "$UI_SESSION_CANCEL" "$UI_ROOT_CANCEL" "$UI_DISCUSSION_CANCEL"
+
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION=cancel \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH="$UI_SNAPSHOT_CANCEL" \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$UI_ANALYST_OUTPUT_CANCEL" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$UI_SESSION_CANCEL" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ui-cancel.out" 2>"$TMPDIR/pi-completion-context-proposal-ui-cancel.err"
+
+python3 - "$UI_SNAPSHOT_CANCEL" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+snapshot = json.loads(Path(sys.argv[1]).read_text())
+assert [action['id'] for action in snapshot['actions']] == ['start', 'edit', 'cancel'], 'cancel snapshot should still expose Start/Edit/Cancel actions'
+assert not Path('.agent').exists(), 'cancel action should not write canonical workflow state'
+PY
+
 echo "context proposal test passed: $ROOT"