@linimin/pi-letscook 0.1.36 → 0.1.37

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" | "explicit_goal" | "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,17 @@ function maybeWriteTestSnapshot(targetPath: string | undefined, content: string)
 }
 
 const COOK_MAIN_CHAT_RERUN_GUIDANCE = "Discuss changes in the main chat and rerun /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 or, as a temporary compatibility shim, pass /cook <text>.";
 
 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";
 }
@@ -785,6 +809,113 @@ 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,
+	options: { mode: "bare" | "explicit"; explicitGoal?: string },
+): void {
+	const snapshotPath = completionTestActiveWorkflowRoutingSnapshotPath();
+	if (!snapshotPath) return;
+	maybeWriteTestSnapshot(
+		snapshotPath,
+		`${JSON.stringify(
+			{
+				mode: options.mode,
+				explicitGoalProvided: Boolean(options.explicitGoal),
+				explicitGoal: options.explicitGoal ?? null,
+				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.",
@@ -1443,13 +1574,85 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 	};
 }
 
+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]) 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, explicitGoal)) ??
+		extractContextProposalFromStructuredSession(recentEntries, projectName);
 }
 
 async function buildGoalAnchoredContextProposal(
@@ -1462,11 +1665,16 @@ async function buildGoalAnchoredContextProposal(
 	const missionSource = explicit?.mission ?? goal;
 	const assessment = assessMissionAnchor(missionSource, projectName);
 	const mission = assessment.derived;
+	const mergeSessionBody = sessionProposal?.source === "analyst";
 	const explicitScope = explicit?.scope ?? [];
-	const sessionScope = (sessionProposal?.scope ?? []).filter((item) => isSessionScopeItemMissionRelevant(item, mission));
+	const sessionScope = mergeSessionBody
+		? (sessionProposal?.scope ?? []).filter((item) => isSessionScopeItemMissionRelevant(item, mission))
+		: [];
+	const sessionConstraints = mergeSessionBody ? sessionProposal?.constraints ?? [] : [];
+	const sessionAcceptance = mergeSessionBody ? sessionProposal?.acceptance ?? [] : [];
 	const scope = uniqueProposalItems([...explicitScope, ...sessionScope]);
-	const constraints = uniqueProposalItems([...(explicit?.constraints ?? []), ...(sessionProposal?.constraints ?? [])]);
-	const acceptance = uniqueProposalItems([...(explicit?.acceptance ?? []), ...(sessionProposal?.acceptance ?? [])]);
+	const constraints = uniqueProposalItems([...(explicit?.constraints ?? []), ...sessionConstraints]);
+	const acceptance = uniqueProposalItems([...(explicit?.acceptance ?? []), ...sessionAcceptance]);
 	const analysis = mergeContextProposalAnalysis(
 		[explicit?.analysis, sessionProposal?.analysis],
 		[goal, mission, ...(sessionProposal?.analysis.possibleNoise ?? []), ...scope, ...constraints, ...acceptance],
@@ -1484,6 +1692,16 @@ async function buildGoalAnchoredContextProposal(
 	};
 }
 
+async function deriveCookContextProposal(
+	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
+	projectName: string,
+	explicitGoal?: string,
+): Promise<ContextProposal | undefined> {
+	return explicitGoal
+		? await buildGoalAnchoredContextProposal(ctx, explicitGoal, projectName)
+		: await extractContextProposalFromSession(ctx, projectName);
+}
+
 async function confirmContextProposal(
 	ctx: { hasUI: boolean; ui: any },
 	proposal: ContextProposal,
@@ -1754,32 +1972,110 @@ 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,
+	explicitGoal?: string,
+): Promise<ActiveWorkflowProposalAssessment> {
+	const currentMission = currentMissionAnchor(snapshot);
+	const projectName = path.basename(snapshot.files.root);
+	const proposal = explicitGoal
+		? await deriveCookContextProposal(ctx, projectName, explicitGoal)
+		: await deriveCookContextProposal(ctx, projectName);
+	const mode = explicitGoal ? "explicit" : "bare";
+	if (!proposal) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "unclear",
+			currentMissionAnchor: currentMission,
+			reason: "missing_proposal",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		return assessment;
+	}
+	const missionsMatch = explicitGoal
+		? missionAnchorsStrictlyEquivalent(currentMission, proposal.mission)
+		: missionAnchorsLikelyEquivalent(currentMission, proposal.mission);
+	if (missionsMatch) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "continue",
+			currentMissionAnchor: currentMission,
+			proposal,
+			reason: "matching_mission",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		return assessment;
+	}
+	if (explicitGoal || shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal)) {
+		const assessment: ActiveWorkflowProposalAssessment = {
+			action: "refocus",
+			currentMissionAnchor: currentMission,
+			proposal,
+			reason: explicitGoal ? "explicit_goal" : "clear_refocus",
+		};
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		return assessment;
+	}
+	const assessment: ActiveWorkflowProposalAssessment = {
+		action: "unclear",
+		currentMissionAnchor: currentMission,
+		proposal,
+		reason: "ambiguous_discussion",
+	};
+	maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+	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 +2087,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 +2100,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,7 +4048,7 @@ 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;
@@ -3768,13 +4064,9 @@ export default function completionExtension(pi: ExtensionAPI) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
 				if (!goal) {
-					const proposal = await extractContextProposalFromSession(ctx, projectName);
+					const proposal = await deriveCookContextProposal(ctx, projectName);
 					if (!proposal) {
-						emitCommandText(
-							ctx,
-							"Usage: /cook <goal> (discussion-only startup needs proposal analyst output; otherwise pass an explicit goal)",
-							"error",
-						);
+						emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(), "info");
 						return;
 					}
 					const decision = await confirmContextProposal(ctx, proposal, {
@@ -3788,7 +4080,11 @@ export default function completionExtension(pi: ExtensionAPI) {
 					kickoffMissionAnchor = decision.missionAnchor;
 					kickoffAnalysis = decision.analysis;
 				} else {
-					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
+					const proposal = await deriveCookContextProposal(ctx, projectName, goal);
+					if (!proposal) {
+						emitCommandText(ctx, "Failed to derive a workflow startup proposal from this goal.", "error");
+						return;
+					}
 					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "Start a completion workflow from this goal?",
 						nonInteractiveBehavior: "accept",
@@ -3824,13 +4120,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,30 +4139,49 @@ 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 assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot);
+					if (assessment.action !== "refocus" || !assessment.proposal) {
+						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot);
+						return;
+					}
+					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.",
 					});
-					const resumeKind =
-						shouldTestAutoContinueOnSessionStart() && completionTestAutoContinuePromptPath() ? "auto-resume" : "resume";
-					await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, resumePrompt, resumeKind);
-					return;
+					if (!decision) {
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "info");
+						return;
+					}
+					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);
 			if (hadSnapshot && explicitGoal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
+					const proposal = await deriveCookContextProposal(ctx, projectName, goal);
+					if (!proposal) {
+						emitCommandText(ctx, "Failed to derive the next workflow round proposal from this goal.", "error");
+						return;
+					}
 					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "Start the next workflow round from this goal?",
 						nonInteractiveBehavior: "accept",
@@ -3886,36 +4197,47 @@ export default function completionExtension(pi: ExtensionAPI) {
 					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);
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "info");
+					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, goal);
+					if (!assessment.proposal) {
+						emitCommandText(ctx, "Failed to derive the replacement workflow proposal from this goal.", "error");
 						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");
+					if (assessment.action === "continue") {
+						kickoffIntent = "continue";
+						kickoffMissionAnchor = assessment.currentMissionAnchor;
+						if (normalizeMissionAnchorText(goal) !== normalizeMissionAnchorText(assessment.currentMissionAnchor)) {
+							emitCommandText(ctx, `Continuing existing workflow without changing mission anchor: ${assessment.currentMissionAnchor}`, "info");
+						}
+					} else {
+						const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, { comparison: "strict" });
+						if (!decision) {
+							emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "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");
+						kickoffIntent = decision.action;
+						kickoffMissionAnchor = decision.currentMissionAnchor;
+						if (decision.action === "refocus") {
+							const proposalDecision = await confirmContextProposal(ctx, assessment.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");
+						}
 					}
 				}
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "description": "Pi package for long-running completion workflows with canonical .agent state, role-based subagents, continuity, and verification helpers.",
   "license": "MIT",
   "private": false,