@linimin/pi-letscook 0.1.36 → 0.1.39

package/extensions/completion/index.ts

@@ -463,6 +463,20 @@ type ExistingWorkflowDecision =
 	| { action: "continue"; currentMissionAnchor: string }
 	| { action: "refocus"; currentMissionAnchor: string; missionAnchor: string };
 
+type ActiveWorkflowProposalAssessment = {
+	action: "continue" | "refocus" | "unclear";
+	currentMissionAnchor: string;
+	proposal?: ContextProposal;
+	reason: "matching_mission" | "clear_refocus" | "missing_proposal" | "ambiguous_discussion";
+};
+
+type ExistingWorkflowChooserOptions = {
+	intro?: string;
+	proposedMissionLabel?: string;
+	refocusChoiceLabel?: string;
+	comparison?: "semantic" | "strict";
+};
+
 function completionTestWorkflowActionOverride(): "continue" | "refocus" | "cancel" | undefined {
 	const raw = process.env.PI_COMPLETION_EXISTING_WORKFLOW_ACTION?.trim().toLowerCase();
 	return raw === "continue" || raw === "refocus" || raw === "cancel" ? raw : undefined;
@@ -494,6 +508,10 @@ function completionTestContextProposalSnapshotPath(): string | undefined {
 	return asString(process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH);
 }
 
+function completionTestActiveWorkflowRoutingSnapshotPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH);
+}
+
 function completionTestDriverPromptPath(): string | undefined {
 	return asString(process.env.PI_COMPLETION_TEST_DRIVER_PROMPT_PATH);
 }
@@ -521,11 +539,19 @@ function maybeWriteTestSnapshot(targetPath: string | undefined, content: string)
 }
 
 const COOK_MAIN_CHAT_RERUN_GUIDANCE = "Discuss changes in the main chat and rerun /cook.";
+const COOK_INLINE_ARG_REJECTION_MESSAGE =
+	"Inline /cook arguments are no longer supported. Clarify the mission in the main chat and rerun bare /cook.";
+const COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL =
+	"Bare /cook failed closed because recent discussion did not contain a clear structured Mission/Scope/Constraints/Acceptance proposal. Add that structure in the main chat and rerun bare /cook.";
 
 function buildCookCancellationMessage(prefix: string): string {
 	return `${prefix}. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
 }
 
+function buildCookStructuredDiscussionFailureMessage(prefix?: string): string {
+	return prefix ? `${prefix} ${COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL}` : COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL;
+}
+
 function shouldDisableContextProposalAnalyst(): boolean {
 	return process.env.PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST === "1";
 }
@@ -729,6 +755,88 @@ function matchContextProposalRoutingHint(
 	return label === "tasktype" ? { field: "taskType", value } : { field: "evaluationProfile", value };
 }
 
+const CONTEXT_PROPOSAL_GENERIC_PLANNING_MISSION_REGEX =
+	/(?:\b(?:start(?:ing)?|begin|continue|continu(?:e|ing)|resume|implement(?:ing)?|execute|execut(?:e|ing)|carry out|work on|ship|build(?:ing)?)\b.*\b(?:this|that|the|current|latest)\s+(?:plan|proposal|spec(?:ification)?|design(?: doc(?:ument)?)?|migration plan)\b|(?:開始|著手|繼續|继续|恢復|恢复)?(?:實作|实现|執行|执行|落地|完成)(?:這個|这个|此|該|该)?(?:方案|計畫|计划|提案|規劃|规划|設計|设计))/iu;
+const CONTEXT_PROPOSAL_PLANNING_ONLY_DELIVERABLE_REGEX =
+	/(?:\b(?:write|draft|prepare|create|produce|share|deliver|document|review)\b.*\b(?:plan|spec(?:ification)?|design(?: doc(?:ument)?)?|migration plan|proposal)\b|(?:撰寫|撰写|編寫|编写|起草|準備|准备|產出|产出|整理|分享|交付|審查|审查).*(?:計畫|计划|規格|规格|設計文件|设计文档|提案|方案))/iu;
+const CONTEXT_PROPOSAL_NO_CODE_DOCS_ONLY_REGEX =
+	/(?:\b(?:docs? only|documentation only|no code(?: changes?)?|without code(?: changes?)?|do not implement|don't implement|planning only|proposal only|spec only|design[- ]doc only|no runtime changes?)\b|(?:只改文件|僅文件|仅文件|不改(?:動)?代碼|不改代码|不要實作|不要实现|只規劃|只规划|僅規劃|仅规划|不改(?:動)?執行|不改运行))/iu;
+const CONTEXT_PROPOSAL_SUPPORT_ONLY_DOCS_REGEX =
+	/(?:^(?:update|edit|document|refresh|write|add)\s+(?:the\s+)?(?:readme|docs?|documentation)\b|^(?:更新|補充|补充|撰寫|撰写|新增)\s*(?:README|文件|文檔|文档))/iu;
+const CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX =
+	/(?:\b(?:normalize|fix|update|add|remove|restore|refactor|ship|support|wire|route|rewrite|replace|preserve|filter|separate|refresh|reroute|suppress|align|convert|reconcile|repair|correct|implement|build|land|block|allow|keep)\b|(?:修正|修復|修复|更新|新增|移除|恢復|恢复|重構|重构|調整|调整|正規化|规范化|規範化|过滤|過濾|分離|分离|刷新|替換|替换|抑制|對齊|对齐|實作|实现|落地|修補|修补|阻止|允許|允许|轉換|转换|保留|保持))/iu;
+
+function contextProposalBodyTexts(proposal: Pick<ContextProposal, "scope" | "constraints" | "acceptance">): string[] {
+	return [...proposal.scope, ...proposal.constraints, ...proposal.acceptance];
+}
+
+function isGenericPlanningMissionAnchor(text: string): boolean {
+	const normalized = normalizeMissionAnchorText(text);
+	if (!normalized) return false;
+	return CONTEXT_PROPOSAL_GENERIC_PLANNING_MISSION_REGEX.test(normalized);
+}
+
+function hasExplicitPlanningOnlyDeliverable(texts: string[]): boolean {
+	return texts.some((text) => CONTEXT_PROPOSAL_PLANNING_ONLY_DELIVERABLE_REGEX.test(normalizeProposalLine(text)));
+}
+
+function hasClearNoCodeOrDocsOnlySignal(texts: string[]): boolean {
+	return texts.some((text) => CONTEXT_PROPOSAL_NO_CODE_DOCS_ONLY_REGEX.test(normalizeProposalLine(text)));
+}
+
+function isSupportOnlyDocumentationItem(text: string): boolean {
+	return CONTEXT_PROPOSAL_SUPPORT_ONLY_DOCS_REGEX.test(normalizeProposalLine(text));
+}
+
+function isImplementationMissionSourceCandidate(text: string): boolean {
+	const normalized = normalizeProposalLine(text);
+	if (!normalized) return false;
+	if (hasExplicitPlanningOnlyDeliverable([normalized])) return false;
+	if (hasClearNoCodeOrDocsOnlySignal([normalized])) return false;
+	if (isSupportOnlyDocumentationItem(normalized)) return false;
+	return CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX.test(normalized);
+}
+
+function hasSupportOnlyDocumentationDeliverable(proposal: Pick<ContextProposal, "scope" | "acceptance">): boolean {
+	const deliverableTexts = [...proposal.scope, ...proposal.acceptance].map((item) => normalizeProposalLine(item)).filter(Boolean);
+	if (deliverableTexts.length === 0) return false;
+	return deliverableTexts.every((item) => isSupportOnlyDocumentationItem(item));
+}
+
+function pickImplementationMissionSource(proposal: Pick<ContextProposal, "scope" | "constraints" | "acceptance">): string | undefined {
+	for (const item of proposal.scope) {
+		if (isImplementationMissionSourceCandidate(item)) return item;
+	}
+	for (const item of proposal.acceptance) {
+		if (isImplementationMissionSourceCandidate(item)) return item;
+	}
+	return undefined;
+}
+
+function finalizeContextProposal(proposal: ContextProposal, projectName: string): ContextProposal | undefined {
+	if (!isGenericPlanningMissionAnchor(proposal.mission)) return proposal;
+	const bodyTexts = contextProposalBodyTexts(proposal);
+	if (hasExplicitPlanningOnlyDeliverable(bodyTexts) || hasClearNoCodeOrDocsOnlySignal(bodyTexts) || hasSupportOnlyDocumentationDeliverable(proposal)) {
+		return proposal;
+	}
+	const missionSource = pickImplementationMissionSource(proposal);
+	if (!missionSource) return undefined;
+	const nextMission = assessMissionAnchor(missionSource, projectName).derived;
+	const normalizedNextMission = normalizeMissionAnchorText(nextMission);
+	if (!normalizedNextMission || isWeakMissionAnchor(normalizedNextMission)) return undefined;
+	if (missionAnchorsStrictlyEquivalent(nextMission, proposal.mission)) return proposal;
+	return {
+		...proposal,
+		mission: nextMission,
+		goalText: buildContextProposalGoalText({
+			mission: nextMission,
+			scope: proposal.scope,
+			constraints: proposal.constraints,
+			acceptance: proposal.acceptance,
+		}),
+	};
+}
+
 const MISSION_SCOPE_FILTER_STOPWORDS = new Set([
 	"a",
 	"an",
@@ -785,6 +893,108 @@ function isSessionScopeItemMissionRelevant(item: string, mission: string): boole
 	return overlap.some((token) => token.length >= 6 || /[\p{Script=Han}]/u.test(token));
 }
 
+function missionAnchorSemanticTokens(text: string): string[] {
+	return [...new Set(missionScopeFilterTokens(normalizeMissionAnchorText(text).toLowerCase()))];
+}
+
+function missionAnchorOrderedTokenOverlapRatio(leftTokens: string[], rightTokens: string[]): number {
+	if (leftTokens.length === 0 || rightTokens.length === 0) return 0;
+	const dp = new Array(rightTokens.length + 1).fill(0);
+	for (const leftToken of leftTokens) {
+		let previous = 0;
+		for (let index = 0; index < rightTokens.length; index += 1) {
+			const nextPrevious = dp[index + 1];
+			if (leftToken === rightTokens[index]) {
+				dp[index + 1] = previous + 1;
+			} else {
+				dp[index + 1] = Math.max(dp[index + 1], dp[index]);
+			}
+			previous = nextPrevious;
+		}
+	}
+	return dp[rightTokens.length] / Math.max(leftTokens.length, rightTokens.length);
+}
+
+function missionAnchorBigramOverlapRatio(leftTokens: string[], rightTokens: string[]): number {
+	if (leftTokens.length < 2 || rightTokens.length < 2) return 0;
+	const leftBigrams = new Set(leftTokens.slice(0, -1).map((token, index) => `${token} ${leftTokens[index + 1]}`));
+	const rightBigrams = new Set(rightTokens.slice(0, -1).map((token, index) => `${token} ${rightTokens[index + 1]}`));
+	if (leftBigrams.size === 0 || rightBigrams.size === 0) return 0;
+	let overlap = 0;
+	for (const bigram of leftBigrams) {
+		if (rightBigrams.has(bigram)) overlap += 1;
+	}
+	return overlap / Math.max(leftBigrams.size, rightBigrams.size);
+}
+
+function missionAnchorsStrictlyEquivalent(left: string, right: string): boolean {
+	return normalizeMissionAnchorText(left).toLowerCase() === normalizeMissionAnchorText(right).toLowerCase();
+}
+
+const MISSION_NEGATION_CUE_REGEX = /(?:^|[^\p{L}\p{N}_])(?:no|not|without|never|cannot|don['’]?t)(?=$|[^\p{L}\p{N}_])/u;
+
+function missionAnchorHasNegationCue(text: string): boolean {
+	return MISSION_NEGATION_CUE_REGEX.test(text);
+}
+
+function missionAnchorsLikelyEquivalent(left: string, right: string): boolean {
+	const normalizedLeft = normalizeMissionAnchorText(left).toLowerCase();
+	const normalizedRight = normalizeMissionAnchorText(right).toLowerCase();
+	if (!normalizedLeft || !normalizedRight) return false;
+	const leftHasNegationCue = missionAnchorHasNegationCue(normalizedLeft);
+	const rightHasNegationCue = missionAnchorHasNegationCue(normalizedRight);
+	if (leftHasNegationCue !== rightHasNegationCue) return false;
+	if (normalizedLeft === normalizedRight) return true;
+	if (!leftHasNegationCue && (normalizedLeft.includes(normalizedRight) || normalizedRight.includes(normalizedLeft))) return true;
+	const leftTokens = missionAnchorSemanticTokens(normalizedLeft);
+	const rightTokens = missionAnchorSemanticTokens(normalizedRight);
+	if (leftTokens.length === 0 || rightTokens.length === 0) return false;
+	const rightSet = new Set(rightTokens);
+	const overlap = leftTokens.filter((token) => rightSet.has(token));
+	if (overlap.length < 3) return false;
+	const maxLen = Math.max(leftTokens.length, rightTokens.length);
+	if (overlap.length / maxLen < 0.75) return false;
+	if (missionAnchorOrderedTokenOverlapRatio(leftTokens, rightTokens) < 0.75) return false;
+	if (Math.min(leftTokens.length, rightTokens.length) < 4) return true;
+	return missionAnchorBigramOverlapRatio(leftTokens, rightTokens) >= 0.5;
+}
+
+function shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal: ContextProposal): boolean {
+	if (proposal.source === "session") {
+		return proposal.scope.length > 0 && proposal.constraints.length > 0 && proposal.acceptance.length > 0;
+	}
+	return (
+		proposal.scope.length > 0 &&
+		proposal.constraints.length > 0 &&
+		proposal.acceptance.length > 0 &&
+		proposal.analysis.possibleNoise.length === 0
+	);
+}
+
+function maybeWriteActiveWorkflowRoutingSnapshot(assessment: ActiveWorkflowProposalAssessment): void {
+	const snapshotPath = completionTestActiveWorkflowRoutingSnapshotPath();
+	if (!snapshotPath) return;
+	maybeWriteTestSnapshot(
+		snapshotPath,
+		`${JSON.stringify(
+			{
+				mode: "bare",
+				action: assessment.action,
+				reason: assessment.reason,
+				currentMissionAnchor: assessment.currentMissionAnchor,
+				proposedMissionAnchor: assessment.proposal?.mission ?? null,
+				proposalSource: assessment.proposal?.source ?? null,
+				possibleNoise: assessment.proposal?.analysis.possibleNoise ?? [],
+				scope: assessment.proposal?.scope ?? [],
+				constraints: assessment.proposal?.constraints ?? [],
+				acceptance: assessment.proposal?.acceptance ?? [],
+			},
+			null,
+			2,
+		)}\n`,
+	);
+}
+
 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.",
@@ -797,7 +1007,6 @@ const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
 	"risks must contain concrete failure modes or regressions that the later workflow should keep in view.",
 	"task_type and evaluation_profile should be candidate routing hints only; reuse the existing completion vocabulary when it clearly fits instead of inventing new schema names.",
 	"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(" ");
 
@@ -852,11 +1061,7 @@ function extractJsonObjectFromText(text: string): string | undefined {
 	return unfenced.slice(start, end + 1);
 }
 
-function parseContextProposalAnalystOutput(
-	raw: string,
-	projectName: string,
-	explicitGoal?: string,
-): ContextProposal | undefined {
+function parseContextProposalAnalystOutput(raw: string, projectName: string): ContextProposal | undefined {
 	const jsonText = extractJsonObjectFromText(raw);
 	if (!jsonText) return undefined;
 	let parsed: unknown;
@@ -866,8 +1071,7 @@ function parseContextProposalAnalystOutput(
 		return undefined;
 	}
 	if (!isRecord(parsed)) return undefined;
-	const explicit = explicitGoal ? parseContextProposal(explicitGoal, projectName) : undefined;
-	const missionSource = explicit?.mission ?? explicitGoal ?? asString(parsed.mission);
+	const missionSource = asString(parsed.mission);
 	if (!missionSource) return undefined;
 	const assessment = assessMissionAnchor(missionSource, projectName);
 	const normalizedMission = normalizeMissionAnchorText(missionSource);
@@ -876,31 +1080,28 @@ function parseContextProposalAnalystOutput(
 	const scope = uniqueProposalItems(asStringArray(parsed.scope));
 	const constraints = uniqueProposalItems(asStringArray(parsed.constraints));
 	const acceptance = uniqueProposalItems(asStringArray(parsed.acceptance));
-	const analysis = mergeContextProposalAnalysis(
-		[
-			explicit?.analysis,
-			buildContextProposalAnalysis({
-				taskType: parsed.task_type ?? parsed.taskType,
-				evaluationProfile: parsed.evaluation_profile ?? parsed.evaluationProfile,
-				critique: asStringArray(parsed.critique),
-				risks: asStringArray(parsed.risks ?? parsed.risk),
-				possibleNoise: asStringArray(parsed.possible_noise ?? parsed.possibleNoise),
-				hintTexts: [raw, mission, ...scope, ...constraints, ...acceptance],
-			}),
-		],
-		[explicitGoal ?? "", raw, mission, ...scope, ...constraints, ...acceptance],
-	);
+	const analysis = buildContextProposalAnalysis({
+		taskType: parsed.task_type ?? parsed.taskType,
+		evaluationProfile: parsed.evaluation_profile ?? parsed.evaluationProfile,
+		critique: asStringArray(parsed.critique),
+		risks: asStringArray(parsed.risks ?? parsed.risk),
+		possibleNoise: asStringArray(parsed.possible_noise ?? parsed.possibleNoise),
+		hintTexts: [raw, mission, ...scope, ...constraints, ...acceptance],
+	});
 	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview: raw.replace(/\s+/g, " ").trim(),
-		source: "analyst",
-	};
+	return finalizeContextProposal(
+		{
+			mission,
+			scope,
+			constraints,
+			acceptance,
+			analysis,
+			goalText,
+			basisPreview: raw.replace(/\s+/g, " ").trim(),
+			source: "analyst",
+		},
+		projectName,
+	);
 }
 
 function contextProposalAnalystModelArg(model: unknown): string | undefined {
@@ -910,17 +1111,9 @@ function contextProposalAnalystModelArg(model: unknown): string | undefined {
 	return provider && id ? `${provider}/${id}` : undefined;
 }
 
-function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[], explicitGoal?: string): string {
+function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[]): 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");
+	return [`Project: ${projectName}`, "Infer the current mission from the discussion.", "", "Recent discussion:", discussion].join("\n");
 }
 
 function contextProposalAnalystProgressLines(activity: LiveRoleActivity): string[] {
@@ -949,14 +1142,13 @@ 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 prompt = buildContextProposalAnalystPrompt(projectName, recentEntries);
 	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];
@@ -1058,18 +1250,17 @@ 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);
+		return parseContextProposalAnalystOutput(testOutput, projectName);
 	}
 	if (recentEntries.length === 0) return undefined;
 	try {
-		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries, explicitGoal);
+		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries);
 		if (!raw) return undefined;
-		return parseContextProposalAnalystOutput(raw, projectName, explicitGoal);
+		return parseContextProposalAnalystOutput(raw, projectName);
 	} catch (error) {
 		console.warn("[completion] context proposal analyst failed", error);
 		return undefined;
@@ -1431,57 +1622,111 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 		hintTexts: [cleaned, mission, ...scope, ...constraints, ...acceptance, ...critique, ...risks],
 	});
 	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview,
-		source: "session",
-	};
+	return finalizeContextProposal(
+		{
+			mission,
+			scope,
+			constraints,
+			acceptance,
+			analysis,
+			goalText,
+			basisPreview,
+			source: "session",
+		},
+		projectName,
+	);
+}
+
+function hasStructuredContextProposalSignal(text: string): boolean {
+	const cleaned = stripCodeBlocks(text).replace(/\r/g, "").trim();
+	if (!cleaned) return false;
+	return /(^|\n)\s*(mission|goal|objective|summary|scope|plan|steps|implementation|constraints?|guardrails|non-goals|acceptance|acceptance criteria|deliverables|verification|critique|concerns?|warnings?|notes?|risks?|hazards?|task[\s_-]*type|evaluation[\s_-]*profile)\s*(?:[:：]\s*|$)/imu.test(
+		cleaned,
+	);
+}
+
+function parseStrictStructuredSessionProposal(text: string, projectName: string): ContextProposal | undefined {
+	const cleaned = stripCodeBlocks(text).replace(/\r/g, "").trim();
+	if (!cleaned) return undefined;
+	const lines = cleaned
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0);
+	if (lines.length === 0) return undefined;
+
+	let section: ContextProposalSection | undefined;
+	const sectionsPresent = new Set<ContextProposalSection>();
+	const missionCandidates: string[] = [];
+
+	for (const rawLine of lines) {
+		const inlineSection = matchInlineProposalSection(rawLine);
+		if (inlineSection) {
+			section = inlineSection.section;
+			sectionsPresent.add(section);
+			if (section === "mission") missionCandidates.push(inlineSection.content);
+			continue;
+		}
+		const headerSection = detectProposalSection(rawLine);
+		if (headerSection) {
+			section = headerSection;
+			sectionsPresent.add(section);
+			continue;
+		}
+		const normalized = bulletText(rawLine) ?? normalizeProposalLine(rawLine);
+		if (normalized && section === "mission") missionCandidates.push(normalized);
+	}
+
+	const requiredSections: ContextProposalSection[] = ["mission", "scope", "constraints", "acceptance"];
+	if (requiredSections.some((candidate) => !sectionsPresent.has(candidate))) return undefined;
+
+	const distinctMissionAnchors = Array.from(
+		new Set(
+			missionCandidates
+				.map((candidate) => normalizeMissionAnchorText(assessMissionAnchor(candidate, projectName).derived))
+				.filter((candidate): candidate is string => Boolean(candidate)),
+		),
+	);
+	if (distinctMissionAnchors.length !== 1) return undefined;
+
+	const proposal = parseContextProposal(cleaned, projectName);
+	if (!proposal) return undefined;
+	if (
+		normalizeMissionAnchorText(proposal.mission) !== distinctMissionAnchors[0] &&
+		!isGenericPlanningMissionAnchor(distinctMissionAnchors[0])
+	) {
+		return undefined;
+	}
+	if (proposal.scope.length === 0 || proposal.constraints.length === 0 || proposal.acceptance.length === 0) return undefined;
+	return { ...proposal, source: "session" };
+}
+
+function extractContextProposalFromStructuredSession(
+	recentEntries: RecentDiscussionEntry[],
+	projectName: string,
+): ContextProposal | undefined {
+	const structuredTexts = recentEntries
+		.slice()
+		.reverse()
+		.map((entry) => entry.text.trim())
+		.filter((text) => hasStructuredContextProposalSignal(text));
+	if (structuredTexts.length === 0) return undefined;
+	return parseStrictStructuredSessionProposal(structuredTexts.join("\n\n"), projectName);
 }
 
 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);
+	return (await analyzeContextProposalWithAgent(ctx, projectName, recentEntries)) ??
+		extractContextProposalFromStructuredSession(recentEntries, projectName);
 }
 
-async function buildGoalAnchoredContextProposal(
+async function deriveCookContextProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
-	goal: string,
 	projectName: string,
-): Promise<ContextProposal> {
-	const explicit = parseContextProposal(goal, projectName);
-	const sessionProposal = await extractContextProposalFromSession(ctx, projectName, goal);
-	const missionSource = explicit?.mission ?? goal;
-	const assessment = assessMissionAnchor(missionSource, projectName);
-	const mission = assessment.derived;
-	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 analysis = mergeContextProposalAnalysis(
-		[explicit?.analysis, sessionProposal?.analysis],
-		[goal, mission, ...(sessionProposal?.analysis.possibleNoise ?? []), ...scope, ...constraints, ...acceptance],
-	);
-	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview: sessionProposal?.basisPreview ?? explicit?.basisPreview ?? goal,
-		source: sessionProposal?.source ?? explicit?.source ?? "session",
-	};
+): Promise<ContextProposal | undefined> {
+	return await extractContextProposalFromSession(ctx, projectName);
 }
 
 async function confirmContextProposal(
@@ -1754,32 +1999,103 @@ function buildEvaluationRoleReminderText(snapshot: CompletionStateSnapshot, role
 	return buildEvaluationRoleContextLines(snapshot, role).join(" ");
 }
 
-async function confirmExistingWorkflowGoal(
+async function assessActiveWorkflowProposalRouting(
+	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
+	snapshot: CompletionStateSnapshot,
+): Promise<ActiveWorkflowProposalAssessment> {
+	const currentMission = currentMissionAnchor(snapshot);
+	const projectName = path.basename(snapshot.files.root);
+	const proposal = await deriveCookContextProposal(ctx, projectName);
+	if (!proposal) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "unclear",
+			currentMissionAnchor: currentMission,
+			reason: "missing_proposal",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
+		return assessment;
+	}
+	if (missionAnchorsLikelyEquivalent(currentMission, proposal.mission)) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "continue",
+			currentMissionAnchor: currentMission,
+			proposal,
+			reason: "matching_mission",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
+		return assessment;
+	}
+	if (shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal)) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "refocus",
+			currentMissionAnchor: currentMission,
+			proposal,
+			reason: "clear_refocus",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
+		return assessment;
+	}
+	const assessment: ActiveWorkflowProposalAssessment = {
+		action: "unclear",
+		currentMissionAnchor: currentMission,
+		proposal,
+		reason: "ambiguous_discussion",
+	};
+	maybeWriteActiveWorkflowRoutingSnapshot(assessment);
+	return assessment;
+}
+
+async function resumeActiveWorkflowFromCanonicalState(
+	pi: any,
+	ctx: { cwd: string; hasUI: boolean; ui: any },
+	snapshot: CompletionStateSnapshot,
+): Promise<void> {
+	const mission = currentMissionAnchor(snapshot);
+	pi.setSessionName(`completion: ${mission.slice(0, 60)}`);
+	const resumePrompt = completionResumePrompt(
+		currentTaskType(snapshot) ?? "(missing)",
+		currentEvaluationProfile(snapshot) ?? "(missing)",
+	);
+	const rootKey = completionRootKey(snapshot, getCtxCwd(ctx));
+	const fingerprint = completionContinuationFingerprint(snapshot) ?? JSON.stringify({
+		kind: "resume",
+		mission_anchor: mission,
+		current_phase: asString(snapshot.state?.current_phase) ?? null,
+		next_mandatory_role: asString(snapshot.state?.next_mandatory_role) ?? null,
+	});
+	const resumeKind = shouldTestAutoContinueOnSessionStart() && completionTestAutoContinuePromptPath() ? "auto-resume" : "resume";
+	await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, resumePrompt, resumeKind);
+}
+
+async function confirmExistingWorkflowProposal(
 	ctx: { hasUI: boolean; ui: any },
 	snapshot: CompletionStateSnapshot,
-	goal: string,
+	proposal: ContextProposal,
+	options: ExistingWorkflowChooserOptions = {},
 ): Promise<ExistingWorkflowDecision | undefined> {
 	const currentMission = currentMissionAnchor(snapshot);
-	const assessment = assessMissionAnchor(goal, path.basename(snapshot.files.root));
-	const normalizedCurrent = normalizeMissionAnchorText(currentMission);
-	const normalizedGoal = normalizeMissionAnchorText(goal);
-	const normalizedProposed = normalizeMissionAnchorText(assessment.derived);
-	if (!normalizedGoal || normalizedGoal === normalizedCurrent || normalizedProposed === normalizedCurrent) {
+	const comparison = options.comparison ?? "semantic";
+	const missionsMatch =
+		comparison === "strict"
+			? missionAnchorsStrictlyEquivalent(currentMission, proposal.mission)
+			: missionAnchorsLikelyEquivalent(currentMission, proposal.mission);
+	if (missionsMatch) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
 	const title = [
 		"Existing completion workflow found",
 		"",
-		"A workflow is already in progress. Choose how /cook should proceed:",
+		options.intro ?? "A workflow is already in progress. Choose how /cook should proceed:",
 		"",
 		"Current mission",
 		currentMission,
 		"",
-		"New proposed mission",
-		assessment.derived,
+		options.proposedMissionLabel ?? "New proposed mission",
+		proposal.mission,
 	].join("\n");
 	const continueChoice = "Continue current workflow\n\nKeep the current mission and treat the new goal as extra direction only.";
 	const refocusChoice =
+		options.refocusChoiceLabel ??
 		"Abandon current workflow and start this new one\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state.";
 	const cancelChoice = `Cancel\n\nKeep the current workflow unchanged. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
 	maybeWriteTestSnapshot(
@@ -1791,7 +2107,7 @@ async function confirmExistingWorkflowGoal(
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
 	if (actionOverride === "refocus") {
-		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: assessment.derived };
+		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: proposal.mission };
 	}
 	if (actionOverride === "cancel") return undefined;
 	if (!getCtxHasUI(ctx)) {
@@ -1804,7 +2120,7 @@ async function confirmExistingWorkflowGoal(
 	const choice = await ui.select(title, [continueChoice, refocusChoice, cancelChoice]);
 	if (!choice || choice === cancelChoice) return undefined;
 	if (choice === refocusChoice) {
-		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: assessment.derived };
+		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: proposal.mission };
 	}
 	return { action: "continue", currentMissionAnchor: currentMission };
 }
@@ -3752,13 +4068,16 @@ export default function completionExtension(pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("cook", {
-		description: "Start or continue the completion workflow for a repo",
+		description: "Discussion-driven /cook workflow: start, continue, refocus, or start the next round",
 		handler: async (args, ctx) => {
-			const explicitGoal = args.trim();
-			let goal = explicitGoal;
+			const inlineArgs = args.trim();
+			if (inlineArgs) {
+				emitCommandText(ctx, COOK_INLINE_ARG_REJECTION_MESSAGE, "info");
+				return;
+			}
+			let goal: string | undefined;
 			const cwd = getCtxCwd(ctx);
 			let snapshot = await loadCompletionSnapshot(cwd);
-			const hadSnapshot = Boolean(snapshot);
 			const workflowDone = isWorkflowDone(snapshot);
 			let kickoffIntent: "auto" | "continue" | "refocus" = "auto";
 			let kickoffMissionAnchor = snapshot ? currentMissionAnchor(snapshot) : undefined;
@@ -3767,40 +4086,21 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!snapshot) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
-				if (!goal) {
-					const proposal = await extractContextProposalFromSession(ctx, projectName);
-					if (!proposal) {
-						emitCommandText(
-							ctx,
-							"Usage: /cook <goal> (discussion-only startup needs proposal analyst output; otherwise pass an explicit goal)",
-							"error",
-						);
-						return;
-					}
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start a completion workflow from the recent discussion?",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal"), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffMissionAnchor = decision.missionAnchor;
-					kickoffAnalysis = decision.analysis;
-				} else {
-					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start a completion workflow from this goal?",
-						nonInteractiveBehavior: "accept",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled workflow startup proposal"), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffMissionAnchor = decision.missionAnchor;
-					kickoffAnalysis = decision.analysis;
+				const proposal = await deriveCookContextProposal(ctx, projectName);
+				if (!proposal) {
+					emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(), "info");
+					return;
+				}
+				const decision = await confirmContextProposal(ctx, proposal, {
+					title: "Start a completion workflow from the recent discussion?",
+				});
+				if (!decision) {
+					emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal"), "info");
+					return;
 				}
+				goal = decision.goalText;
+				kickoffMissionAnchor = decision.missionAnchor;
+				kickoffAnalysis = decision.analysis;
 				const startupRouting = finalizeContextProposalAnalysis(kickoffAnalysis, [goal ?? kickoffMissionAnchor ?? projectName]);
 				const created = await scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName, {
 					analysis: startupRouting,
@@ -3824,13 +4124,9 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!goal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = await extractContextProposalFromSession(ctx, projectName);
+					const proposal = await deriveCookContextProposal(ctx, projectName);
 					if (!proposal) {
-						emitCommandText(
-							ctx,
-							"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",
-						);
+						emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage("The previous completion workflow is already done."), "info");
 						return;
 					}
 					const decision = await confirmContextProposal(ctx, proposal, {
@@ -3847,78 +4143,41 @@ export default function completionExtension(pi: ExtensionAPI) {
 					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
 					emitCommandText(ctx, `Started a new completion workflow round from recent discussion: ${decision.missionAnchor}`, "info");
 				} else {
-					const mission = currentMissionAnchor(snapshot);
-					pi.setSessionName(`completion: ${mission.slice(0, 60)}`);
-					const resumePrompt = completionResumePrompt(
-						currentTaskType(snapshot) ?? "(missing)",
-						currentEvaluationProfile(snapshot) ?? "(missing)",
-					);
-					const rootKey = completionRootKey(snapshot, getCtxCwd(ctx));
-					const fingerprint = completionContinuationFingerprint(snapshot) ?? JSON.stringify({
-						kind: "resume",
-						mission_anchor: currentMissionAnchor(snapshot),
-						current_phase: asString(snapshot.state?.current_phase) ?? null,
-						next_mandatory_role: asString(snapshot.state?.next_mandatory_role) ?? null,
-					});
-					const resumeKind =
-						shouldTestAutoContinueOnSessionStart() && completionTestAutoContinuePromptPath() ? "auto-resume" : "resume";
-					await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, resumePrompt, resumeKind);
-					return;
-				}
-			}
-			kickoffMissionAnchor = kickoffMissionAnchor ?? currentMissionAnchor(snapshot);
-			if (hadSnapshot && explicitGoal) {
-				if (workflowDone) {
-					const projectName = path.basename(snapshot.files.root);
-					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start the next workflow round from this goal?",
-						nonInteractiveBehavior: "accept",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal"), "info");
+					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot);
+					if (assessment.action !== "refocus" || !assessment.proposal) {
+						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot);
 						return;
 					}
-					goal = decision.goalText;
-					kickoffIntent = "refocus";
-					kickoffMissionAnchor = decision.missionAnchor;
-					await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText, decision.analysis);
-					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-					emitCommandText(ctx, `Started a new completion workflow round from explicit goal: ${decision.missionAnchor}`, "info");
-				} else {
-					const decision = await confirmExistingWorkflowGoal(ctx, snapshot, goal);
+					const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, {
+						intro: "Recent non-command discussion suggests a different workflow. Choose how /cook should proceed:",
+						proposedMissionLabel: "Proposed mission from recent discussion",
+						refocusChoiceLabel:
+							"Start new workflow from recent discussion\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state.",
+					});
 					if (!decision) {
 						emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "info");
 						return;
 					}
-					kickoffIntent = decision.action;
-					kickoffMissionAnchor = decision.currentMissionAnchor;
-					if (decision.action === "refocus") {
-						const projectName = path.basename(snapshot.files.root);
-						const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-						const proposalDecision = await confirmContextProposal(ctx, proposal, {
-							title: "Start the replacement workflow from this goal?",
-							nonInteractiveBehavior: "accept",
-						});
-						if (!proposalDecision) {
-							emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal"), "info");
-							return;
-						}
-						goal = proposalDecision.goalText;
-						await refocusCompletionMission(
-							snapshot,
-							proposalDecision.missionAnchor,
-							proposalDecision.goalText,
-							proposalDecision.analysis,
-						);
-						snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-						kickoffMissionAnchor = proposalDecision.missionAnchor;
-						emitCommandText(ctx, `Refocused completion mission to: ${proposalDecision.missionAnchor}`, "info");
-					} else if (normalizeMissionAnchorText(goal) !== normalizeMissionAnchorText(decision.currentMissionAnchor)) {
-						emitCommandText(ctx, `Continuing existing workflow without changing mission anchor: ${decision.currentMissionAnchor}`, "info");
+					if (decision.action === "continue") {
+						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot);
+						return;
 					}
+					const proposalDecision = await confirmContextProposal(ctx, assessment.proposal, {
+						title: "Start the replacement workflow from recent discussion?",
+					});
+					if (!proposalDecision) {
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal"), "info");
+						return;
+					}
+					goal = proposalDecision.goalText;
+					kickoffIntent = "refocus";
+					kickoffMissionAnchor = proposalDecision.missionAnchor;
+					await refocusCompletionMission(snapshot, proposalDecision.missionAnchor, proposalDecision.goalText, proposalDecision.analysis);
+					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
+					emitCommandText(ctx, `Refocused completion mission from recent discussion to: ${proposalDecision.missionAnchor}`, "info");
 				}
 			}
+			kickoffMissionAnchor = kickoffMissionAnchor ?? currentMissionAnchor(snapshot);
 			pi.setSessionName(`completion: ${kickoffMissionAnchor.slice(0, 60)}`);
 			const kickoffPrompt = completionKickoff(
 				goal,