@linimin/pi-letscook 0.1.46 → 0.1.48

package/CHANGELOG.md

@@ -2,10 +2,20 @@
 
 ## Unreleased
 
+## 0.1.48
+
+### Fixed
+
+- stopped injecting active completion workflow routing into ordinary non-`/cook` main-chat turns after a repo had been activated earlier in the same Pi process, so stale canonical stop-wave state can no longer pull unrelated user requests into `completion-regrounder` unless a fresh `/cook` driver prompt is actually in flight
+
+## 0.1.47
+
 ### Changed
 
 - removed inline `/cook <text>` argument support so bare `/cook` is now the only supported workflow entrypoint
 - made runtime, deterministic regressions, README guidance, and packaged release parity fail closed when command arguments are passed instead of discussion driving proposal derivation
+- made bare `/cook` weight the latest clear implementation intent ahead of older background discussion, preserve alternate recent missions for chooser-driven disambiguation, and summarize each candidate directly in the active-workflow chooser instead of forcing a single guessed replacement path
+- made bare `/cook` suppress reopening already completed or already verified work by comparing recent discussion against canonical mission, active-slice, and verification-evidence context before startup/refocus proposal confirmation
 
 ## 0.1.44
 

package/README.md

@@ -55,9 +55,9 @@ Bare `/cook` is the only supported workflow entrypoint.
 
 | Repo state | `/cook` behavior |
 |---|---|
-| No workflow yet | Summarizes recent main-chat discussion into a startup proposal, then asks for approval with **Start** or **Cancel**. If the discussion is weak, ambiguous, assistant-produced, or only a plan/spec/design-doc/proposal artifact instead of concrete repo changes, `/cook` fails closed without writing `.agent/**` state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. |
-| Active workflow exists | Reads the current mission plus recent non-command main-chat discussion. Matching or unclear discussion resumes from canonical `.agent/**` state. Clear replacement discussion about different concrete repo changes opens a chooser first, then only rewrites canonical state after the follow-on **Start** confirmation. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. `/cook <text>` is rejected without running proposal routing or rewriting workflow state. |
-| Previous workflow is `done` | Starts the next round from recent main-chat discussion, then asks for approval with **Start** or **Cancel**. Weak, ambiguous, assistant-produced, or planning-artifact-only discussion fails closed without rewriting canonical state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. `/cook <text>` is rejected before any next-round proposal is derived. |
+| No workflow yet | Summarizes recent main-chat discussion into a startup proposal, weighting the latest clear implementation intent ahead of older background discussion, then asks for approval with **Start** or **Cancel**. If the discussion is weak, ambiguous, assistant-produced, or only a plan/spec/design-doc/proposal artifact instead of concrete repo changes, `/cook` fails closed without writing `.agent/**` state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. |
+| Active workflow exists | Reads the current mission plus recent non-command main-chat discussion. Matching or unclear discussion resumes from canonical `.agent/**` state. Clear replacement discussion about different concrete repo changes opens a chooser first, then only rewrites canonical state after the follow-on **Start** confirmation. If recent discussion implies more than one plausible replacement mission, `/cook` keeps the current workflow parked behind a multi-candidate chooser instead of silently resuming or guessing. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. `/cook <text>` is rejected without running proposal routing or rewriting workflow state. |
+| Previous workflow is `done` | Starts the next round from recent main-chat discussion, then asks for approval with **Start** or **Cancel**. Weak, ambiguous, assistant-produced, or planning-artifact-only discussion fails closed without rewriting canonical state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. Recent discussion that only restates already-completed or already-verified work also fails closed instead of reopening the finished mission. `/cook <text>` is rejected before any next-round proposal is derived. |
 
 ## Approval-only confirmation and fail-closed behavior
 
@@ -69,15 +69,16 @@ All startup, next-round, and replacement proposals are **approval-only**:
 
 When `/cook` cannot derive a clear startup, next-round, or replacement proposal for concrete repo changes from recent main-chat discussion, it fails closed instead of guessing. That means no canonical `.agent/**` state is created or rewritten until the discussion is clarified in the main chat and you rerun `/cook`. Tracked docs-only work such as README/CHANGELOG updates is still execution-ready, but assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts are not enough to start or refocus a workflow on their own. `/cook <text>` also fails closed immediately and tells you to move that text into the main chat before rerunning bare `/cook`.
 
-When an active workflow already exists and recent discussion clearly suggests a different workflow, `/cook` shows a separate chooser first:
+When an active workflow already exists and recent discussion suggests a different workflow, `/cook` shows a separate chooser first. The chooser can stay conservative or list multiple candidate replacements when the latest discussion contains more than one plausible implementation goal:
 
 - **Continue current workflow**
 - **Start new workflow from recent discussion**
+- **Start alternate workflow from recent discussion** (when a second plausible mission exists)
 - **Cancel**
 
-Only the follow-on startup/replacement proposal uses the approval-only Start/Cancel gate, and canonical `.agent/**` state changes happen only after **Start** is accepted.
+Chooser options summarize each candidate mission with its latest scope/constraint/acceptance highlights before the follow-on approval-only Start/Cancel gate. Canonical `.agent/**` state changes still happen only after **Start** is accepted.
 
-When you accept startup or refocus from that flow, `/cook` persists the chosen `task_type` and `evaluation_profile` across `.agent/profile.json`, `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json`, and records the accepted critique outcome in canonical continuation state before the re-ground round begins.
+When you accept startup or refocus from that flow, `/cook` persists the chosen `task_type` and `evaluation_profile` across `.agent/profile.json`, `.agent/state.json`, `.agent/plan.json`, and `.agent/active-slice.json`, and records the accepted critique outcome plus any alternate-mission / suppression notes in canonical continuation state before the re-ground round begins.
 
 ## Observability
 

package/extensions/completion/driver.ts

@@ -20,9 +20,12 @@ type ContextProposalAnalysis = {
 	critique: string[];
 	risks: string[];
 	possibleNoise: string[];
+	alternateMissions: string[];
+	suppressedCompletedTopics: string[];
+	suppressedNegatedTopics: string[];
 };
 
-type ContextProposal = {
+type ContextProposalAlternate = {
 	mission: string;
 	scope: string[];
 	constraints: string[];
@@ -33,6 +36,10 @@ type ContextProposal = {
 	source: "session" | "analyst";
 };
 
+type ContextProposal = ContextProposalAlternate & {
+	alternateProposals: ContextProposalAlternate[];
+};
+
 type ContextProposalDecision = {
 	missionAnchor: string;
 	goalText: string;
@@ -41,7 +48,7 @@ type ContextProposalDecision = {
 
 type ExistingWorkflowDecision =
 	| { action: "continue"; currentMissionAnchor: string }
-	| { action: "refocus"; currentMissionAnchor: string; missionAnchor: string };
+	| { action: "refocus"; currentMissionAnchor: string; missionAnchor: string; proposal: ContextProposal };
 
 type ActiveWorkflowProposalAssessment = {
 	action: "continue" | "refocus" | "unclear";
@@ -55,6 +62,7 @@ type ExistingWorkflowChooserOptions = {
 	comparison?: "strict" | "semantic";
 	proposedMissionLabel?: string;
 	refocusChoiceLabel?: string;
+	alternateChoiceLabel?: string;
 };
 
 type DriverContext = {
@@ -115,11 +123,13 @@ export type CompletionDriverDeps = {
 	missionAnchorsLikelyEquivalent: (left: string, right: string) => boolean;
 	missionAnchorsStrictlyEquivalent: (left: string, right: string) => boolean;
 	shouldTreatBareActiveWorkflowProposalAsClearRefocus: (proposal: ContextProposal) => boolean;
+	activateCompletionRoutingForRoot: (root: string | undefined) => void;
 	maybeWriteTestSnapshot: (targetPath: string | undefined, content: string) => void;
 	completionTestDriverPromptPath: () => string | undefined;
 	completionTestAutoContinuePromptPath: () => string | undefined;
 	completionTestExistingWorkflowChooserSnapshotPath: () => string | undefined;
 	completionTestWorkflowActionOverride: () => "continue" | "refocus" | "cancel" | undefined;
+	completionTestWorkflowMissionOverride: () => string | undefined;
 	shouldSkipDriverKickoffForTests: () => boolean;
 	shouldTestAutoContinueOnSessionStart: () => boolean;
 };
@@ -241,6 +251,14 @@ function rememberParkedDriverContinuation(rootKey: string, fingerprint: string):
 	tracker.inFlight = false;
 }
 
+function summarizeProposalForChoice(proposal: ContextProposalAlternate): string {
+	const parts: string[] = [`Mission\n${proposal.mission}`];
+	if (proposal.scope.length > 0) parts.push(`Scope\n- ${proposal.scope.slice(0, 2).join("\n- ")}`);
+	if (proposal.constraints.length > 0) parts.push(`Constraints\n- ${proposal.constraints.slice(0, 1).join("\n- ")}`);
+	if (proposal.acceptance.length > 0) parts.push(`Acceptance\n- ${proposal.acceptance.slice(0, 1).join("\n- ")}`);
+	return parts.join("\n\n");
+}
+
 async function queueCompletionDriverPrompt(
 	pi: ExtensionAPI,
 	ctx: { cwd: string; hasUI: boolean; ui: any },
@@ -379,14 +397,17 @@ async function confirmExistingWorkflowProposal(
 ): Promise<ExistingWorkflowDecision | undefined> {
 	const currentMission = currentMissionAnchor(snapshot);
 	const comparison = options.comparison ?? "semantic";
-	const missionsMatch =
+	const candidateProposals = [proposal, ...(proposal.alternateProposals ?? [])].filter((candidate, index, list) =>
+		list.findIndex((other) => deps.missionAnchorsStrictlyEquivalent(other.mission, candidate.mission)) === index,
+	);
+	const missionMatches = (candidate: ContextProposalAlternate): boolean =>
 		comparison === "strict"
-			? deps.missionAnchorsStrictlyEquivalent(currentMission, proposal.mission)
-			: deps.missionAnchorsLikelyEquivalent(currentMission, proposal.mission);
-	if (missionsMatch) {
+			? deps.missionAnchorsStrictlyEquivalent(currentMission, candidate.mission)
+			: deps.missionAnchorsLikelyEquivalent(currentMission, candidate.mission);
+	if (candidateProposals.some((candidate) => missionMatches(candidate))) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
-	const title = [
+	const titleLines = [
 		"Existing completion workflow found",
 		"",
 		options.intro ?? "A workflow is already in progress. Choose how /cook should proceed:",
@@ -394,24 +415,42 @@ async function confirmExistingWorkflowProposal(
 		"Current mission",
 		currentMission,
 		"",
-		options.proposedMissionLabel ?? "New proposed mission",
+		options.proposedMissionLabel ?? "Primary proposed mission",
 		proposal.mission,
-	].join("\n");
+	];
+	if (candidateProposals.length > 1) {
+		titleLines.push("", "Alternate recent missions", ...candidateProposals.slice(1).map((candidate) => candidate.mission));
+	}
+	const title = titleLines.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 buildRefocusChoice = (candidate: ContextProposalAlternate, variant: "primary" | "alternate") =>
+		variant === "primary"
+			? `${options.refocusChoiceLabel ?? "Start new workflow from recent discussion\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."}\n\n${summarizeProposalForChoice(candidate)}`
+			: `${options.alternateChoiceLabel ?? "Start alternate workflow from recent discussion\n\nReview this alternate replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."}\n\n${summarizeProposalForChoice(candidate)}`;
+	const refocusChoices = candidateProposals.map((candidate, index) => buildRefocusChoice(candidate, index === 0 ? "primary" : "alternate"));
 	const cancelChoice = `Cancel\n\nKeep the current workflow unchanged. ${deps.mainChatRerunGuidance}`;
 	deps.maybeWriteTestSnapshot(
 		deps.completionTestExistingWorkflowChooserSnapshotPath(),
-		`${JSON.stringify({ title, choices: [continueChoice, refocusChoice, cancelChoice] }, null, 2)}\n`,
+		`${JSON.stringify({ title, candidateMissions: candidateProposals.map((candidate) => candidate.mission), choices: [continueChoice, ...refocusChoices, cancelChoice] }, null, 2)}\n`,
 	);
+	const missionOverride = deps.completionTestWorkflowMissionOverride();
+	if (missionOverride) {
+		const matched = candidateProposals.find((candidate) => deps.missionAnchorsStrictlyEquivalent(candidate.mission, missionOverride));
+		if (matched) {
+			return {
+				action: "refocus",
+				currentMissionAnchor: currentMission,
+				missionAnchor: matched.mission,
+				proposal: { ...matched, alternateProposals: [] },
+			};
+		}
+	}
 	const actionOverride = deps.completionTestWorkflowActionOverride();
 	if (actionOverride === "continue") {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
 	if (actionOverride === "refocus") {
-		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: proposal.mission };
+		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: proposal.mission, proposal };
 	}
 	if (actionOverride === "cancel") return undefined;
 	if (!deps.getCtxHasUI(ctx)) {
@@ -421,10 +460,20 @@ async function confirmExistingWorkflowProposal(
 	if (!ui) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
-	const choice = await ui.select(title, [continueChoice, refocusChoice, cancelChoice]);
+	const choice = await ui.select(title, [continueChoice, ...refocusChoices, cancelChoice]);
 	if (!choice || choice === cancelChoice) return undefined;
-	if (choice === refocusChoice) {
-		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: proposal.mission };
+	if (choice === continueChoice) {
+		return { action: "continue", currentMissionAnchor: currentMission };
+	}
+	const matchedIndex = refocusChoices.indexOf(choice);
+	if (matchedIndex >= 0) {
+		const selected = candidateProposals[matchedIndex];
+		return {
+			action: "refocus",
+			currentMissionAnchor: currentMission,
+			missionAnchor: selected.mission,
+			proposal: matchedIndex === 0 ? proposal : { ...selected, alternateProposals: [] },
+		};
 	}
 	return { action: "continue", currentMissionAnchor: currentMission };
 }
@@ -534,6 +583,7 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 				deps.emitCommandText(ctx, "Failed to load completion workflow state", "error");
 				return;
 			}
+			deps.activateCompletionRoutingForRoot(snapshot.files.root);
 			if (!goal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
@@ -557,15 +607,19 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 					deps.emitCommandText(ctx, `Started a new completion workflow round from recent discussion: ${decision.missionAnchor}`, "info");
 				} else {
 					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, deps);
-					if (assessment.action !== "refocus" || !assessment.proposal) {
+					if (!assessment.proposal || assessment.action === "continue") {
 						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
 						return;
 					}
 					const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, deps, {
-						intro: "Recent non-command discussion suggests a different workflow. Choose how /cook should proceed:",
+						intro:
+							assessment.action === "refocus"
+								? "Recent non-command discussion suggests a different workflow. Choose how /cook should proceed:"
+								: "Recent discussion may point to a different implementation goal. Review the current mission and the latest inferred mission before deciding 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.",
+						comparison: assessment.action === "refocus" ? "semantic" : "strict",
 					});
 					if (!decision) {
 						deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation", deps), "info");
@@ -575,8 +629,12 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
 						return;
 					}
-					const proposalDecision = await deps.confirmContextProposal(ctx, assessment.proposal, {
-						title: "Start the replacement workflow from recent discussion?",
+					const selectedProposal = decision.proposal;
+					const proposalDecision = await deps.confirmContextProposal(ctx, selectedProposal, {
+						title:
+							assessment.action === "refocus"
+								? "Start the replacement workflow from recent discussion?"
+								: "Start the latest inferred workflow from recent discussion?",
 					});
 					if (!proposalDecision) {
 						deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal", deps), "info");

package/extensions/completion/index.ts

@@ -145,6 +145,10 @@ function completionTestWorkflowActionOverride(): "continue" | "refocus" | "cance
 	return raw === "continue" || raw === "refocus" || raw === "cancel" ? raw : undefined;
 }
 
+function completionTestWorkflowMissionOverride(): string | undefined {
+	return asString(process.env.PI_COMPLETION_EXISTING_WORKFLOW_MISSION);
+}
+
 function shouldSkipDriverKickoffForTests(): boolean {
 	return process.env.PI_COMPLETION_SKIP_DRIVER_KICKOFF === "1";
 }
@@ -238,8 +242,19 @@ function hasCompletionRoutingActivation(snapshot: CompletionStateSnapshot | unde
 	return activatedCompletionRoutingRoots.has(path.resolve(snapshot.files.root));
 }
 
-function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined): boolean {
-	return hasCompletionRoutingActivation(snapshot);
+function latestUserOrCustomTurnText(ctx: { sessionManager?: any }): string | undefined {
+	return collectRecentDiscussionEntries(ctx as { sessionManager: any }, { isRecord, asString, isStaleContextError }, 1)[0]?.text;
+}
+
+function isCompletionDriverPromptTurn(ctx: { sessionManager?: any }): boolean {
+	const latest = latestUserOrCustomTurnText(ctx);
+	if (!latest) return false;
+	if (!/^\/skill:completion-protocol\b/.test(latest)) return false;
+	return /(?:Start or continue the completion workflow for this repo\.|Resume the completion workflow from canonical state\.)/.test(latest);
+}
+
+function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
+	return hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx);
 }
 
 function buildDoneWorkflowBoundaryReminder(snapshot: CompletionStateSnapshot): string {
@@ -271,6 +286,9 @@ function maybeWriteActiveWorkflowRoutingSnapshot(assessment: ActiveWorkflowPropo
 				proposedMissionAnchor: assessment.proposal?.mission ?? null,
 				proposalSource: assessment.proposal?.source ?? null,
 				possibleNoise: assessment.proposal?.analysis.possibleNoise ?? [],
+				alternateMissions: assessment.proposal?.analysis.alternateMissions ?? [],
+				suppressedCompletedTopics: assessment.proposal?.analysis.suppressedCompletedTopics ?? [],
+				suppressedNegatedTopics: assessment.proposal?.analysis.suppressedNegatedTopics ?? [],
 				scope: assessment.proposal?.scope ?? [],
 				constraints: assessment.proposal?.constraints ?? [],
 				acceptance: assessment.proposal?.acceptance ?? [],
@@ -361,14 +379,41 @@ async function deriveCookContextProposal(
 	projectName: string,
 ): Promise<ContextProposal | undefined> {
 	const recentEntries = collectRecentDiscussionEntries(ctx, { isRecord, asString, isStaleContextError });
+	const snapshot = await loadCompletionSnapshot(getCtxCwd(ctx));
+	const workflowContextLines = snapshot
+		? [
+			`current mission anchor: ${asString(snapshot.state?.mission_anchor) ?? asString(snapshot.plan?.mission_anchor) ?? asString(snapshot.active?.mission_anchor) ?? "(none)"}`,
+			`continuation policy: ${asString(snapshot.state?.continuation_policy) ?? "(none)"}`,
+			`latest completed slice: ${asString(snapshot.state?.latest_completed_slice) ?? "(none)"}`,
+			`latest verified slice: ${asString(snapshot.state?.latest_verified_slice) ?? "(none)"}`,
+			`active slice goal: ${asString(snapshot.active?.goal) ?? "(none)"}`,
+			`active slice why_now: ${asString(snapshot.active?.why_now) ?? "(none)"}`,
+			`verification goal: ${asString(snapshot.verificationEvidence?.goal) ?? "(none)"}`,
+			`verification summary: ${asString(snapshot.verificationEvidence?.summary) ?? "(none)"}`,
+		]
+		: [];
 	return await deriveCookContextProposalFromRecentDiscussion(projectName, recentEntries, {
 		asString,
 		asStringArray,
+		workflowContext: snapshot
+			? {
+				currentMissionAnchor:
+					asString(snapshot.state?.mission_anchor) ?? asString(snapshot.plan?.mission_anchor) ?? asString(snapshot.active?.mission_anchor),
+				latestCompletedSlice: asString(snapshot.state?.latest_completed_slice),
+				latestVerifiedSlice: asString(snapshot.state?.latest_verified_slice),
+				activeSliceGoal: asString(snapshot.active?.goal),
+				activeSliceWhyNow: asString(snapshot.active?.why_now),
+				verificationGoal: asString(snapshot.verificationEvidence?.goal),
+				verificationSummary: asString(snapshot.verificationEvidence?.summary),
+				continuationPolicy: asString(snapshot.state?.continuation_policy),
+			}
+			: undefined,
 		analyzeContextProposal: async (entries) =>
 			await analyzeContextProposalWithAgent({
 				ctx,
 				projectName,
 				recentEntries: entries,
+				workflowContextLines,
 				liveRoleActivityByRoot,
 				completionStatusKey: COMPLETION_STATUS_KEY,
 				safeUiCall,
@@ -881,6 +926,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		completionTestDriverPromptPath,
 		completionTestExistingWorkflowChooserSnapshotPath,
 		completionTestWorkflowActionOverride,
+		completionTestWorkflowMissionOverride,
 		confirmContextProposal,
 		deriveCookContextProposal,
 		emitCommandText,
@@ -890,6 +936,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		getCtxUi,
 		hasRunningCompletionRole,
 		maybeWriteActiveWorkflowRoutingSnapshot,
+		activateCompletionRoutingForRoot,
 		maybeWriteTestSnapshot,
 		missionAnchorsLikelyEquivalent,
 		missionAnchorsStrictlyEquivalent,
@@ -902,7 +949,10 @@ export default function completionExtension(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		await refreshCompletionStatus({ ctx, ...statusSurfaceArgs });
 		if (shouldTestAutoContinueOnSessionStart()) {
-			await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
+			const snapshot = await loadCompletionSnapshot(getCtxCwd(ctx));
+			if (hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx)) {
+				await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
+			}
 		}
 	});
 
@@ -916,17 +966,20 @@ export default function completionExtension(pi: ExtensionAPI) {
 			await fsp.rm(snapshot.files.compactionMarkerPath, { force: true });
 		}
 		await refreshCompletionStatus({ ctx, ...statusSurfaceArgs });
-		await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
+		if (hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx)) {
+			await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
+		}
 	});
 
 	pi.on("before_agent_start", async (_event, ctx) => {
 		const loaded = await loadCompletionDataForReminder(getCtxCwd(ctx));
-		if (loaded) {
+		const driverPromptTurn = isCompletionDriverPromptTurn(ctx);
+		if (loaded && driverPromptTurn) {
 			const rootKey = completionRootKey(loaded.snapshot, getCtxCwd(ctx));
 			const fingerprint = completionContinuationFingerprint(loaded.snapshot);
 			if (fingerprint) markQueuedDriverPromptInFlight(rootKey, fingerprint);
 		}
-		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot)) return;
+		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot, ctx)) return;
 		const additions = isWorkflowDone(loaded.snapshot)
 			? [buildDoneWorkflowBoundaryReminder(loaded.snapshot)]
 			: [composeSystemReminder(loaded.snapshot, loaded.sliceHistory, loaded.stopHistory)];

package/extensions/completion/prompt-surfaces.ts

@@ -63,8 +63,23 @@ export function buildContextProposalCritiqueText(analysis: ContextProposalAnalys
 		lines.push("Possible noise");
 		for (const item of analysis.possibleNoise) lines.push(`- ${item}`);
 	}
+	if (analysis.alternateMissions.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Alternate recent missions");
+		for (const item of analysis.alternateMissions) lines.push(`- ${item}`);
+	}
+	if (analysis.suppressedCompletedTopics.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Suppressed completed topics");
+		for (const item of analysis.suppressedCompletedTopics) lines.push(`- ${item}`);
+	}
+	if (analysis.suppressedNegatedTopics.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Suppressed negated topics");
+		for (const item of analysis.suppressedNegatedTopics) lines.push(`- ${item}`);
+	}
 	if (lines.length === 0) {
-		return "No critique, risk, or possible-noise notes were derived for this startup proposal.";
+		return "No critique, risk, noise, alternate-mission, or suppression notes were derived for this startup proposal.";
 	}
 	return lines.join("\n");
 }
@@ -101,6 +116,9 @@ export function buildContextProposalContinuationReason(
 		analysis.critique.length > 0 ? `accepted critique=${deps.truncateInline(analysis.critique.join(" | "), 160)}` : "accepted critique=none",
 		summarizeContextProposalAnalysisItems("risks", analysis.risks, deps.truncateInline),
 		summarizeContextProposalAnalysisItems("possible_noise", analysis.possibleNoise, deps.truncateInline),
+		summarizeContextProposalAnalysisItems("alternate_missions", analysis.alternateMissions, deps.truncateInline),
+		summarizeContextProposalAnalysisItems("suppressed_completed", analysis.suppressedCompletedTopics, deps.truncateInline),
+		summarizeContextProposalAnalysisItems("suppressed_negated", analysis.suppressedNegatedTopics, deps.truncateInline),
 	].filter((part): part is string => Boolean(part));
 	return `${prefix} ${deps.truncateInline(goalText, 220)} | startup routing: task_type=${analysis.taskType ?? deps.defaultTaskType}; evaluation_profile=${analysis.evaluationProfile ?? deps.defaultEvaluationProfile}; critique outcome=${critiqueParts.join("; ")}`;
 }
@@ -177,8 +195,14 @@ export function buildContextProposalConfirmationSelectItems(layout: ContextPropo
 	}));
 }
 
-export function buildContextProposalAnalystPrompt(projectName: string, discussion: string): string {
-	const lines = [`Project: ${projectName}`, "Infer the current mission from the discussion."];
+export function buildContextProposalAnalystPrompt(projectName: string, discussion: string, contextLines: string[] = []): string {
+	const lines = [
+		`Project: ${projectName}`,
+		"Infer the current implementation mission from the discussion.",
+		"Prefer the latest clear user implementation intent over older background context.",
+		"Treat stale, completed, or explicitly negated topics as context to ignore unless the latest discussion clearly reopens them.",
+	];
+	if (contextLines.length > 0) lines.push("", "Canonical workflow context:", ...contextLines);
 	lines.push("", "Recent discussion:", discussion || "(none)");
 	return lines.join("\n");
 }

package/extensions/completion/proposal.ts

@@ -14,9 +14,12 @@ export type ContextProposalAnalysis = {
 	critique: string[];
 	risks: string[];
 	possibleNoise: string[];
+	alternateMissions: string[];
+	suppressedCompletedTopics: string[];
+	suppressedNegatedTopics: string[];
 };
 
-export type ContextProposal = {
+export type ContextProposalAlternate = {
 	mission: string;
 	scope: string[];
 	constraints: string[];
@@ -27,6 +30,10 @@ export type ContextProposal = {
 	source: "session" | "analyst";
 };
 
+export type ContextProposal = ContextProposalAlternate & {
+	alternateProposals: ContextProposalAlternate[];
+};
+
 export type ContextProposalSection = "mission" | "scope" | "constraints" | "acceptance" | "critique" | "risks";
 
 export type RecentDiscussionEntry = {
@@ -67,6 +74,17 @@ export type ContextProposalConfirmOptions = {
 	nonInteractiveBehavior?: "accept" | "cancel";
 };
 
+export type ContextProposalWorkflowContext = {
+	currentMissionAnchor?: string;
+	latestCompletedSlice?: string;
+	latestVerifiedSlice?: string;
+	activeSliceGoal?: string;
+	activeSliceWhyNow?: string;
+	verificationGoal?: string;
+	verificationSummary?: string;
+	continuationPolicy?: string;
+};
+
 type ProposalCommonDeps = {
 	asString: (value: unknown) => string | undefined;
 	asStringArray: (value: unknown) => string[];
@@ -324,6 +342,41 @@ export function serializeRecentDiscussionEntries(entries: RecentDiscussionEntry[
 		.join("\n\n");
 }
 
+const RECENT_DISCUSSION_IMPLEMENTATION_INTENT_REGEX =
+	/(?:\b(?: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|edit|document|write)\b|(?:修正|修復|修复|更新|新增|移除|恢復|恢复|重構|重构|調整|调整|過濾|过滤|分離|分离|刷新|替換|替换|抑制|對齊|对齐|實作|实现|落地|修補|修补|阻止|允許|允许|轉換|转换|保留|保持))/iu;
+
+function hasRecentDiscussionImplementationIntent(text: string, stripCodeBlocksFn: (text: string) => string): boolean {
+	const cleaned = stripCodeBlocksFn(text).replace(/\r/g, " ").trim();
+	if (!cleaned) return false;
+	return hasStructuredContextProposalSignal(cleaned, stripCodeBlocksFn) || RECENT_DISCUSSION_IMPLEMENTATION_INTENT_REGEX.test(cleaned);
+}
+
+function recentDiscussionWindows(
+	recentEntries: RecentDiscussionEntry[],
+	stripCodeBlocksFn: (text: string) => string,
+): RecentDiscussionEntry[][] {
+	if (recentEntries.length === 0) return [];
+	const windows: RecentDiscussionEntry[][] = [];
+	const seen = new Set<string>();
+	const pushWindow = (entries: RecentDiscussionEntry[]) => {
+		if (entries.length === 0) return;
+		const key = entries.map((entry) => `${entry.role}:${entry.text}`).join("\n---\n");
+		if (seen.has(key)) return;
+		seen.add(key);
+		windows.push(entries);
+	};
+	const latestEntry = recentEntries[0];
+	if (hasRecentDiscussionImplementationIntent(latestEntry.text, stripCodeBlocksFn)) {
+		pushWindow([latestEntry]);
+	}
+	const recentIntentWindow = recentEntries.filter((entry, index) => index < 3);
+	if (recentIntentWindow.some((entry) => hasRecentDiscussionImplementationIntent(entry.text, stripCodeBlocksFn))) {
+		pushWindow(recentIntentWindow);
+	}
+	pushWindow(recentEntries);
+	return windows;
+}
+
 export function extractJsonObjectFromText(text: string): string | undefined {
 	const trimmed = text.trim();
 	if (!trimmed) return undefined;
@@ -455,12 +508,26 @@ export function buildContextProposalAnalysis(args: {
 	critique?: string[];
 	risks?: string[];
 	possibleNoise?: string[];
+	alternateMissions?: string[];
+	suppressedCompletedTopics?: string[];
+	suppressedNegatedTopics?: string[];
 	hintTexts?: string[];
 }, deps: Pick<ProposalCommonDeps, "asString">): ContextProposalAnalysis {
 	const critique = uniqueProposalItems(args.critique ?? []);
 	const risks = uniqueProposalItems(args.risks ?? []);
 	const possibleNoise = uniqueProposalItems(args.possibleNoise ?? []);
-	const hintTexts = [...(args.hintTexts ?? []), ...critique, ...risks, ...possibleNoise];
+	const alternateMissions = uniqueProposalItems(args.alternateMissions ?? []);
+	const suppressedCompletedTopics = uniqueProposalItems(args.suppressedCompletedTopics ?? []);
+	const suppressedNegatedTopics = uniqueProposalItems(args.suppressedNegatedTopics ?? []);
+	const hintTexts = [
+		...(args.hintTexts ?? []),
+		...critique,
+		...risks,
+		...possibleNoise,
+		...alternateMissions,
+		...suppressedCompletedTopics,
+		...suppressedNegatedTopics,
+	];
 	const taskType = normalizeContextProposalTaskTypeHint(args.taskType, deps.asString) ?? inferContextProposalTaskType(hintTexts);
 	const evaluationProfile =
 		normalizeContextProposalEvaluationProfileHint(args.evaluationProfile, deps.asString) ??
@@ -471,6 +538,9 @@ export function buildContextProposalAnalysis(args: {
 		critique,
 		risks,
 		possibleNoise,
+		alternateMissions,
+		suppressedCompletedTopics,
+		suppressedNegatedTopics,
 	};
 }
 
@@ -481,18 +551,33 @@ function mergeContextProposalAnalysis(
 	const critique = uniqueProposalItems(sources.flatMap((source) => source?.critique ?? []));
 	const risks = uniqueProposalItems(sources.flatMap((source) => source?.risks ?? []));
 	const possibleNoise = uniqueProposalItems(sources.flatMap((source) => source?.possibleNoise ?? []));
+	const alternateMissions = uniqueProposalItems(sources.flatMap((source) => source?.alternateMissions ?? []));
+	const suppressedCompletedTopics = uniqueProposalItems(sources.flatMap((source) => source?.suppressedCompletedTopics ?? []));
+	const suppressedNegatedTopics = uniqueProposalItems(sources.flatMap((source) => source?.suppressedNegatedTopics ?? []));
+	const mergedHints = [
+		...hintTexts,
+		...critique,
+		...risks,
+		...possibleNoise,
+		...alternateMissions,
+		...suppressedCompletedTopics,
+		...suppressedNegatedTopics,
+	];
 	const taskType =
 		sources.map((source) => source?.taskType).find((value): value is string => Boolean(value)) ??
-		inferContextProposalTaskType([...hintTexts, ...critique, ...risks, ...possibleNoise]);
+		inferContextProposalTaskType(mergedHints);
 	const evaluationProfile =
 		sources.map((source) => source?.evaluationProfile).find((value): value is string => Boolean(value)) ??
-		inferContextProposalEvaluationProfile([...hintTexts, ...critique, ...risks, ...possibleNoise], taskType);
+		inferContextProposalEvaluationProfile(mergedHints, taskType);
 	return {
 		taskType,
 		evaluationProfile,
 		critique,
 		risks,
 		possibleNoise,
+		alternateMissions,
+		suppressedCompletedTopics,
+		suppressedNegatedTopics,
 	};
 }
 
@@ -507,6 +592,9 @@ export function finalizeContextProposalAnalysis(
 		critique: merged.critique,
 		risks: merged.risks,
 		possibleNoise: merged.possibleNoise,
+		alternateMissions: merged.alternateMissions,
+		suppressedCompletedTopics: merged.suppressedCompletedTopics,
+		suppressedNegatedTopics: merged.suppressedNegatedTopics,
 	};
 }
 
@@ -610,7 +698,109 @@ function finalizeContextProposal(proposal: ContextProposal, projectName: string,
 	};
 }
 
+function proposalLikelyReopensCompletedWork(proposal: ContextProposal): boolean {
+	const corpus = [proposal.mission, proposal.basisPreview, ...proposal.scope, ...proposal.constraints, ...proposal.acceptance]
+		.map((text) => normalizeProposalLine(text).toLowerCase())
+		.filter(Boolean)
+		.join("\n");
+	return /(again|reopen|follow[- ]?up|next round|another round|rerun|revisit|再次|重新|下一輪|下一轮|延續|延续|回歸|回归)/iu.test(corpus);
+}
+
+function missionTextOverlapsTopic(mission: string, topic: string): boolean {
+	if (!mission || !topic) return false;
+	const missionTokens = missionAnchorSemanticTokens(mission);
+	const topicTokens = missionAnchorSemanticTokens(topic);
+	if (missionTokens.length === 0 || topicTokens.length === 0) return false;
+	const topicSet = new Set(topicTokens);
+	const overlap = missionTokens.filter((token) => topicSet.has(token));
+	return overlap.length >= Math.min(2, Math.min(missionTokens.length, topicTokens.length));
+}
+
+function proposalOverlapsTopic(proposal: ContextProposal, topic: string): boolean {
+	if (!topic.trim()) return false;
+	if (missionTextOverlapsTopic(proposal.mission, topic)) return true;
+	const bodyTexts = [proposal.basisPreview, ...proposal.scope, ...proposal.constraints, ...proposal.acceptance].filter(Boolean);
+	return bodyTexts.some((text) => missionTextOverlapsTopic(text, topic) || missionTextOverlapsTopic(topic, text));
+}
+
+function extractSuppressedNegatedTopics(proposal: ContextProposal): string[] {
+	return uniqueProposalItems(
+		proposal.constraints.filter((item) => looksLikeConstraint(item) && CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX.test(normalizeProposalLine(item))),
+	);
+}
+
+function applyWorkflowContextToProposal(
+	proposal: ContextProposal | undefined,
+	context: ContextProposalWorkflowContext | undefined,
+	deps: ProposalCommonDeps,
+): ContextProposal | undefined {
+	if (!proposal) return proposal;
+	const possibleNoise = [...proposal.analysis.possibleNoise];
+	const alternateMissions = [...proposal.analysis.alternateMissions];
+	const suppressedCompletedTopics = [...proposal.analysis.suppressedCompletedTopics];
+	const suppressedNegatedTopics = [...proposal.analysis.suppressedNegatedTopics, ...extractSuppressedNegatedTopics(proposal)];
+	if (!context) {
+		return {
+			...proposal,
+			analysis: finalizeContextProposalAnalysis(
+				{
+					...proposal.analysis,
+					possibleNoise,
+					alternateMissions,
+					suppressedCompletedTopics,
+					suppressedNegatedTopics,
+				},
+				[proposal.goalText, proposal.mission],
+			),
+		};
+	}
+	const completedTopics = [
+		context.latestCompletedSlice?.trim(),
+		context.latestVerifiedSlice?.trim(),
+		context.verificationGoal?.trim(),
+		context.verificationSummary?.trim(),
+	].filter((value): value is string => Boolean(value));
+	for (const topic of completedTopics) {
+		if (proposalOverlapsTopic(proposal, topic) && !proposalLikelyReopensCompletedWork(proposal)) {
+			suppressedCompletedTopics.push(topic);
+			possibleNoise.push(`already completed: ${topic}`);
+			return undefined;
+		}
+	}
+	const activeTopics = [context.activeSliceGoal?.trim(), context.activeSliceWhyNow?.trim()].filter((value): value is string => Boolean(value));
+	for (const topic of activeTopics) {
+		if (proposalOverlapsTopic(proposal, topic) && proposal.analysis.alternateMissions.length === 0) {
+			possibleNoise.push(`overlaps canonical active slice: ${topic}`);
+		}
+	}
+	const currentMissionAnchor = context.currentMissionAnchor?.trim();
+	if (
+		context.continuationPolicy === "done" &&
+		currentMissionAnchor &&
+		deps.missionAnchorsStrictlyEquivalent(proposal.mission, currentMissionAnchor) &&
+		!proposalLikelyReopensCompletedWork(proposal)
+	) {
+		suppressedCompletedTopics.push(currentMissionAnchor);
+		possibleNoise.push(`historical completed mission: ${currentMissionAnchor}`);
+		return undefined;
+	}
+	return {
+		...proposal,
+		analysis: finalizeContextProposalAnalysis(
+			{
+				...proposal.analysis,
+				possibleNoise,
+				alternateMissions,
+				suppressedCompletedTopics,
+				suppressedNegatedTopics,
+			},
+			[proposal.goalText, proposal.mission, ...completedTopics, ...activeTopics, currentMissionAnchor ?? ""],
+		),
+	};
+}
+
 export function shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal: ContextProposal): boolean {
+	if (proposal.analysis.alternateMissions.length > 0) return false;
 	if (proposal.source === "session") {
 		return proposal.scope.length > 0 && proposal.constraints.length > 0 && proposal.acceptance.length > 0;
 	}
@@ -654,6 +844,7 @@ export function parseContextProposalAnalystOutput(
 	const scope = uniqueProposalItems(deps.asStringArray(parsed.scope));
 	const constraints = uniqueProposalItems(deps.asStringArray(parsed.constraints));
 	const acceptance = uniqueProposalItems(deps.asStringArray(parsed.acceptance));
+	const alternateMissions = deps.asStringArray(parsed.alternate_missions ?? parsed.alternateMissions);
 	const analysis = buildContextProposalAnalysis(
 		{
 			taskType: parsed.task_type ?? parsed.taskType,
@@ -661,6 +852,9 @@ export function parseContextProposalAnalystOutput(
 			critique: deps.asStringArray(parsed.critique),
 			risks: deps.asStringArray(parsed.risks ?? parsed.risk),
 			possibleNoise: deps.asStringArray(parsed.possible_noise ?? parsed.possibleNoise),
+			alternateMissions,
+			suppressedCompletedTopics: deps.asStringArray(parsed.completed_topics ?? parsed.completedTopics),
+			suppressedNegatedTopics: deps.asStringArray(parsed.negated_topics ?? parsed.negatedTopics),
 			hintTexts: [raw, mission, ...scope, ...constraints, ...acceptance],
 		},
 		deps,
@@ -676,6 +870,16 @@ export function parseContextProposalAnalystOutput(
 			goalText,
 			basisPreview: raw.replace(/\s+/g, " ").trim(),
 			source: "analyst",
+			alternateProposals: alternateMissions.map((alternateMission) => ({
+				mission: alternateMission,
+				scope: [],
+				constraints: [],
+				acceptance: [],
+				analysis: finalizeContextProposalAnalysis(undefined, [alternateMission]),
+				goalText: buildContextProposalGoalText({ mission: alternateMission, scope: [], constraints: [], acceptance: [] }),
+				basisPreview: raw.replace(/\s+/g, " ").trim(),
+				source: "analyst",
+			})),
 		},
 		projectName,
 		deps,
@@ -685,9 +889,10 @@ export function parseContextProposalAnalystOutput(
 export function buildContextProposalAnalystPromptFromEntries(
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
+	contextLines: string[] = [],
 	serializeEntries: (entries: RecentDiscussionEntry[]) => string = serializeRecentDiscussionEntries,
 ): string {
-	return buildContextProposalAnalystPrompt(projectName, serializeEntries(recentEntries));
+	return buildContextProposalAnalystPrompt(projectName, serializeEntries(recentEntries), contextLines);
 }
 
 export function parseContextProposal(text: string, projectName: string, deps: ProposalParseDeps): ContextProposal | undefined {
@@ -836,6 +1041,7 @@ export function parseContextProposal(text: string, projectName: string, deps: Pr
 			goalText,
 			basisPreview,
 			source: "session",
+			alternateProposals: [],
 		},
 		projectName,
 		deps,
@@ -850,7 +1056,26 @@ export function hasStructuredContextProposalSignal(text: string, stripCodeBlocks
 	);
 }
 
-export function parseStrictStructuredSessionProposal(text: string, projectName: string, deps: ProposalParseDeps): ContextProposal | undefined {
+function splitStructuredProposalBlocks(text: string): string[] {
+	const lines = text.split("\n");
+	const blocks: string[] = [];
+	let startIndex = 0;
+	for (let index = 0; index < lines.length; index += 1) {
+		const rawLine = lines[index].trim();
+		const inlineSection = matchInlineProposalSection(rawLine);
+		const headerSection = inlineSection?.section ?? detectProposalSection(rawLine);
+		if (index > 0 && headerSection === "mission") {
+			const block = lines.slice(startIndex, index).join("\n").trim();
+			if (block) blocks.push(block);
+			startIndex = index;
+		}
+	}
+	const tail = lines.slice(startIndex).join("\n").trim();
+	if (tail) blocks.push(tail);
+	return blocks;
+}
+
+function parseStrictSingleStructuredSessionProposal(text: string, projectName: string, deps: ProposalParseDeps): ContextProposal | undefined {
 	const cleaned = deps.stripCodeBlocks(text).replace(/\r/g, "").trim();
 	if (!cleaned) return undefined;
 	const lines = cleaned
@@ -902,7 +1127,45 @@ export function parseStrictStructuredSessionProposal(text: string, projectName:
 		return undefined;
 	}
 	if (proposal.scope.length === 0 || proposal.constraints.length === 0 || proposal.acceptance.length === 0) return undefined;
-	return { ...proposal, source: "session" };
+	return { ...proposal, source: "session", alternateProposals: proposal.alternateProposals ?? [] };
+}
+
+export function parseStrictStructuredSessionProposal(text: string, projectName: string, deps: ProposalParseDeps): ContextProposal | undefined {
+	const cleaned = deps.stripCodeBlocks(text).replace(/\r/g, "").trim();
+	if (!cleaned) return undefined;
+	const blocks = splitStructuredProposalBlocks(cleaned);
+	const proposals = blocks
+		.map((block) => parseStrictSingleStructuredSessionProposal(block, projectName, deps))
+		.filter((proposal): proposal is ContextProposal => Boolean(proposal));
+	if (proposals.length === 0) return undefined;
+	const primary = proposals[proposals.length - 1];
+	const alternateProposals = proposals
+		.slice(0, -1)
+		.filter((proposal) => !deps.missionAnchorsStrictlyEquivalent(proposal.mission, primary.mission))
+		.map((proposal) => ({
+			mission: proposal.mission,
+			scope: proposal.scope,
+			constraints: proposal.constraints,
+			acceptance: proposal.acceptance,
+			analysis: proposal.analysis,
+			goalText: proposal.goalText,
+			basisPreview: proposal.basisPreview,
+			source: proposal.source,
+		}));
+	const alternateMissions = uniqueProposalItems(alternateProposals.map((proposal) => proposal.mission));
+	if (alternateMissions.length === 0) return { ...primary, alternateProposals: [] };
+	return {
+		...primary,
+		alternateProposals,
+		analysis: finalizeContextProposalAnalysis(
+			{
+				...primary.analysis,
+				alternateMissions,
+				possibleNoise: [...primary.analysis.possibleNoise, ...alternateMissions.map((mission) => `alternate recent mission: ${mission}`)],
+			},
+			[primary.goalText, primary.mission, ...alternateMissions],
+		),
+	};
 }
 
 export function extractContextProposalFromStructuredSession(
@@ -924,11 +1187,21 @@ export async function deriveCookContextProposalFromRecentDiscussion(
 	recentEntries: RecentDiscussionEntry[],
 	deps: ProposalParseDeps & {
 		analyzeContextProposal?: (recentEntries: RecentDiscussionEntry[]) => Promise<ContextProposal | undefined>;
+		workflowContext?: ContextProposalWorkflowContext;
 	},
 ): Promise<ContextProposal | undefined> {
 	if (recentEntries.length === 0) return undefined;
-	return (await deps.analyzeContextProposal?.(recentEntries)) ??
-		extractContextProposalFromStructuredSession(recentEntries, projectName, deps);
+	for (const candidateEntries of recentDiscussionWindows(recentEntries, deps.stripCodeBlocks)) {
+		const analyzed = applyWorkflowContextToProposal(await deps.analyzeContextProposal?.(candidateEntries), deps.workflowContext, deps);
+		if (analyzed) return analyzed;
+		const structured = applyWorkflowContextToProposal(
+			extractContextProposalFromStructuredSession(candidateEntries, projectName, deps),
+			deps.workflowContext,
+			deps,
+		);
+		if (structured) return structured;
+	}
+	return undefined;
 }
 
 export function resolveContextProposalConfirmationAction(

package/extensions/completion/role-runner.ts

@@ -58,6 +58,7 @@ export type AnalyzeContextProposalWithAgentParams = {
 	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any };
 	projectName: string;
 	recentEntries: RecentDiscussionEntry[];
+	workflowContextLines?: string[];
 	liveRoleActivityByRoot: Map<string, LiveRoleActivity>;
 	completionStatusKey: string;
 	safeUiCall: (action: () => void) => void;
@@ -75,14 +76,18 @@ 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, critique, risks, task_type, evaluation_profile, confidence, possible_noise.",
+	"You may additionally include optional keys alternate_missions, completed_topics, and negated_topics when they are clearly supported by the discussion and canonical workflow context.",
 	"mission must be a concise implementation mission anchor sentence.",
+	"Prefer the latest clear user implementation intent over older background context when they differ.",
+	"Do not reopen work that the canonical workflow context says is done, completed, historical, or already covered unless the latest discussion clearly asks to revisit it.",
+	"Treat stale, weakly related, or explicitly negated topics as noise instead of mission scope.",
 	"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.",
 	"critique must contain operator-facing cautions, concerns, or reminders that should be shown separately from mission and scope later.",
 	"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.",
+	"possible_noise should list discussion points that look stale, weakly related, unsafe to promote into scope, or already completed elsewhere.",
 	"When discussion is insufficient, prefer empty arrays and a low confidence value over invention.",
 ].join(" ");
 const STARTUP_ANALYST_ROLE = "cook-proposal-analyst";
@@ -167,7 +172,7 @@ async function runContextProposalAnalystSubprocess(params: AnalyzeContextProposa
 	const cwd = params.getCtxCwd(ctx);
 	const runCwd = findCompletionRoot(cwd) ?? findRepoRoot(cwd) ?? cwd;
 	const rootKey = completionRootKey(undefined, cwd);
-	const prompt = buildContextProposalAnalystPromptFromEntries(projectName, recentEntries);
+	const prompt = buildContextProposalAnalystPromptFromEntries(projectName, recentEntries, params.workflowContextLines);
 	const systemPromptTemp = await writeTempFile(runCwd, "pi-cook-proposal-analyst-", CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT);
 	const args: string[] = ["--mode", "json", "-p", "--no-session", "--append-system-prompt", systemPromptTemp.filePath, "--model", modelArg, prompt];
 	const invocation = getPiInvocation(args);

package/package.json

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

package/scripts/context-proposal-test.sh

@@ -158,6 +158,85 @@ PY
 
 rm -rf .agent
 
+# No workflow yet: when multiple structured discussions exist, bare /cook should prioritize the latest
+# concrete implementation mission instead of failing closed on older structured context.
+SESSION_ZERO_LATEST_WINDOW="$TMPDIR/session-zero-latest-window.jsonl"
+DISCUSSION_ZERO_LATEST_OLDER=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Keep observability regression coverage truthful.'
+DISCUSSION_ZERO_LATEST_NEWER=$'Mission: Fix login redirect callback behavior.\nScope:\n- Update the callback redirect decision logic.\nConstraints:\n- Do not refactor the broader auth flow.\nAcceptance:\n- Add a regression test for returning to the requested page.'
+DISCUSSION_SNAPSHOT_ZERO_LATEST_WINDOW="$TMPDIR/context-proposal-latest-window.json"
+python3 - "$SESSION_ZERO_LATEST_WINDOW" "$ROOT" "$DISCUSSION_ZERO_LATEST_OLDER" "$DISCUSSION_ZERO_LATEST_NEWER" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+session_path = Path(sys.argv[1])
+cwd = sys.argv[2]
+older = sys.argv[3]
+newer = sys.argv[4]
+session_path.parent.mkdir(parents=True, exist_ok=True)
+entries = [
+    {
+        "type": "session",
+        "version": 3,
+        "id": "11111111-1111-4111-8111-111111111111",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "cwd": cwd,
+    },
+    {
+        "type": "message",
+        "id": "a1b2c3d4",
+        "parentId": None,
+        "timestamp": "2026-01-01T00:00:01.000Z",
+        "message": {
+            "role": "user",
+            "content": older,
+            "timestamp": 1767225601000,
+        },
+    },
+    {
+        "type": "message",
+        "id": "b2c3d4e5",
+        "parentId": "a1b2c3d4",
+        "timestamp": "2026-01-01T00:00:02.000Z",
+        "message": {
+            "role": "user",
+            "content": newer,
+            "timestamp": 1767225602000,
+        },
+    },
+]
+with session_path.open('w', encoding='utf-8') as fh:
+    for entry in entries:
+        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+PY
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_ZERO_LATEST_WINDOW" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ZERO_LATEST_WINDOW" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-latest-window.out" 2>"$TMPDIR/pi-completion-context-proposal-latest-window.err"
+
+python3 - "$DISCUSSION_SNAPSHOT_ZERO_LATEST_WINDOW" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Fix login redirect callback behavior.'
+proposal = json.loads(Path(sys.argv[1]).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())
+
+assert proposal['mission'] == mission, 'latest structured discussion should win over older structured context'
+assert proposal['scope'] == ['Update the callback redirect decision logic.'], 'latest structured discussion should preserve the latest scope only'
+assert proposal['analysis']['suppressedNegatedTopics'] == ['Do not refactor the broader auth flow.'], 'latest structured discussion should preserve negated implementation topics separately from the mission'
+assert state['mission_anchor'] == mission, 'latest structured discussion should initialize state.json with the latest mission'
+assert plan['mission_anchor'] == mission, 'latest structured discussion should initialize plan.json with the latest mission'
+assert active['mission_anchor'] == mission, 'latest structured discussion should initialize active-slice.json with the latest mission'
+PY
+
+rm -rf .agent
+
 # No workflow yet: bare /cook should fail closed when a required structured section is missing and analyst output is unavailable.
 SESSION_ZERO_MISSING="$TMPDIR/session-zero-missing-section.jsonl"
 DISCUSSION_ZERO_MISSING=$'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.'
@@ -182,26 +261,35 @@ assert '/cook failed closed' in output, 'missing-section structured discussion s
 assert 'Mission/Scope/Constraints/Acceptance' in output, 'missing-section structured discussion should explain the strict fallback requirement'
 PY
 
-# No workflow yet: bare /cook should fail closed on ambiguous structured discussion when analyst output is unavailable.
+# No workflow yet: when one structured discussion message contains multiple complete mission blocks,
+# bare /cook should prioritize the latest block and preserve earlier blocks as alternate missions.
 SESSION_ZERO_AMBIG="$TMPDIR/session-zero-ambiguous.jsonl"
-DISCUSSION_ZERO_AMBIG=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\nMission: Ship an unrelated widget overhaul.\nScope:\n- Replace the widget entirely.'
+DISCUSSION_ZERO_AMBIG=$'Mission: Remove the completion status line while keeping the completion widget.\nScope:\n- Keep the non-running completion widget.\nConstraints:\n- Do not reintroduce any other completion status surface.\nAcceptance:\n- Update README to match the shipped behavior.\nMission: Ship an unrelated widget overhaul.\nScope:\n- Replace the widget entirely.\nConstraints:\n- Do not modify the completion widget.\nAcceptance:\n- Land the unrelated overhaul changes only.'
+DISCUSSION_SNAPSHOT_ZERO_AMBIG="$TMPDIR/context-proposal-ambiguous-latest-block.json"
 write_session "$SESSION_ZERO_AMBIG" "$ROOT" "$DISCUSSION_ZERO_AMBIG"
 
 PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
 PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_ZERO_AMBIG" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 pi --session "$SESSION_ZERO_AMBIG" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-ambiguous.out" 2>"$TMPDIR/pi-completion-context-proposal-ambiguous.err"
 
-python3 - "$TMPDIR/pi-completion-context-proposal-ambiguous.out" "$TMPDIR/pi-completion-context-proposal-ambiguous.err" <<'PY'
+python3 - "$DISCUSSION_SNAPSHOT_ZERO_AMBIG" <<'PY'
+import json
 import sys
 from pathlib import Path
 
-output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
-assert not Path('.agent').exists(), 'ambiguous structured discussion should fail closed without writing canonical state'
-assert '/cook failed closed' in output, 'ambiguous structured discussion should explain the fail-closed startup outcome'
-assert 'Mission/Scope/Constraints/Acceptance' in output, 'ambiguous structured discussion should explain the strict fallback requirement'
+mission = 'Ship an unrelated widget overhaul.'
+proposal = json.loads(Path(sys.argv[1]).read_text())
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert proposal['mission'] == mission, 'latest complete mission block should win inside a single structured discussion message'
+assert proposal['analysis']['alternateMissions'] == ['Remove the completion status line while keeping the completion widget.'], 'earlier complete mission blocks should be preserved as alternate missions'
+assert state['mission_anchor'] == mission, 'latest complete mission block should initialize canonical mission state'
 PY
 
+rm -rf .agent
+
 # No workflow yet: bare /cook structured fallback should normalize placeholder planning phrasing
 # into the concrete implementation mission when scope/acceptance clearly describe shipped work.
 SESSION_ZERO_NORMALIZED="$TMPDIR/session-zero-normalized.jsonl"
@@ -699,6 +787,100 @@ assert plan['mission_anchor'] == mission, 'summary-only active bare /cook should
 assert active['mission_anchor'] == mission, 'summary-only active bare /cook should keep active-slice.json unchanged'
 PY
 
+# Active workflow: when recent discussion suggests a different implementation goal but the proposal is
+# still incomplete, bare /cook should surface the chooser instead of silently resuming the current workflow.
+SESSION_ONE_AMBIGUOUS_CHOOSER="$TMPDIR/session-one-ambiguous-chooser.jsonl"
+DISCUSSION_ONE_AMBIGUOUS_CHOOSER=$'Mission: Fix login redirect callback behavior.\nScope:\n- Update the callback redirect decision logic for the current auth flow.'
+AMBIGUOUS_ROUTING_ONE="$TMPDIR/active-ambiguous-routing.json"
+AMBIGUOUS_CHOOSER_ONE="$TMPDIR/active-ambiguous-chooser.json"
+AMBIGUOUS_RESUME_PROMPT_ONE="$TMPDIR/unexpected-active-ambiguous-resume.txt"
+AMBIGUOUS_PROPOSAL_ONE="$TMPDIR/unexpected-active-ambiguous-proposal.json"
+write_session "$SESSION_ONE_AMBIGUOUS_CHOOSER" "$ROOT" "$DISCUSSION_ONE_AMBIGUOUS_CHOOSER"
+
+PI_COMPLETION_EXISTING_WORKFLOW_ACTION=cancel \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT='{"mission":"Fix login redirect callback behavior.","scope":["Update the callback redirect decision logic for the current auth flow."],"constraints":[],"acceptance":[],"task_type":"completion-workflow","evaluation_profile":"completion-rubric-v1","confidence":0.72,"possible_noise":["older completion widget cleanup"]}' \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$AMBIGUOUS_ROUTING_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$AMBIGUOUS_CHOOSER_ONE" \
+PI_COMPLETION_TEST_DRIVER_PROMPT_PATH="$AMBIGUOUS_RESUME_PROMPT_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$AMBIGUOUS_PROPOSAL_ONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ONE_AMBIGUOUS_CHOOSER" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-ambiguous-chooser.out" 2>"$TMPDIR/pi-completion-context-proposal-active-ambiguous-chooser.err"
+
+python3 - "$AMBIGUOUS_ROUTING_ONE" "$AMBIGUOUS_CHOOSER_ONE" "$AMBIGUOUS_RESUME_PROMPT_ONE" "$AMBIGUOUS_PROPOSAL_ONE" "$TMPDIR/pi-completion-context-proposal-active-ambiguous-chooser.out" "$TMPDIR/pi-completion-context-proposal-active-ambiguous-chooser.err" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mission = 'Remove the completion status line while keeping the completion widget.'
+routing = json.loads(Path(sys.argv[1]).read_text())
+chooser = json.loads(Path(sys.argv[2]).read_text())
+resume_path = Path(sys.argv[3])
+proposal_path = Path(sys.argv[4])
+output = Path(sys.argv[5]).read_text() + Path(sys.argv[6]).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())
+
+assert routing['mode'] == 'bare', 'ambiguous active bare /cook should snapshot bare routing mode'
+assert routing['action'] == 'unclear', 'incomplete replacement discussion should stay ambiguous until the chooser resolves it'
+assert routing['reason'] == 'ambiguous_discussion', 'incomplete replacement discussion should record the ambiguous-discussion reason'
+assert routing['currentMissionAnchor'] == mission, 'ambiguous chooser routing should preserve the current mission anchor'
+assert routing['proposedMissionAnchor'] == 'Fix login redirect callback behavior.', 'ambiguous chooser routing should expose the latest inferred mission'
+assert chooser['title'].startswith('Existing completion workflow found'), 'ambiguous active bare /cook should still open the existing-workflow chooser'
+assert chooser['choices'][0].startswith('Continue current workflow'), 'ambiguous chooser should keep the continue option'
+assert chooser['choices'][1].startswith('Start new workflow from recent discussion'), 'ambiguous chooser should offer the recent-discussion replacement option'
+assert not resume_path.exists(), 'ambiguous active bare /cook should not silently queue a resume prompt before the chooser resolves it'
+assert not proposal_path.exists(), 'ambiguous chooser cancel should not open the final proposal confirmation'
+assert 'Discuss changes in the main chat and rerun /cook.' in output, 'ambiguous chooser cancel should redirect users back to the main chat and rerun /cook'
+assert state['mission_anchor'] == mission, 'ambiguous chooser cancel should keep state.json unchanged'
+assert plan['mission_anchor'] == mission, 'ambiguous chooser cancel should keep plan.json unchanged'
+assert active['mission_anchor'] == mission, 'ambiguous chooser cancel should keep active-slice.json unchanged'
+PY
+
+# Active workflow: when recent discussion contains multiple complete replacement missions, bare /cook should
+# surface all candidates and allow the chooser to select a non-primary alternate mission.
+SESSION_ONE_MULTI_CANDIDATE="$TMPDIR/session-one-multi-candidate.jsonl"
+DISCUSSION_ONE_MULTI_CANDIDATE=$'Mission: Fix login redirect callback behavior.\nScope:\n- Update the callback redirect decision logic for the current auth flow.\nConstraints:\n- Do not refactor the broader auth flow.\nAcceptance:\n- Add a regression test for returning to the requested page.\nMission: Add logout redirect regression coverage.\nScope:\n- Add coverage for logout redirect behavior.\nConstraints:\n- Do not change login redirect behavior in this pass.\nAcceptance:\n- Land a dedicated logout redirect regression test.'
+MULTI_ROUTING_ONE="$TMPDIR/active-multi-routing.json"
+MULTI_CHOOSER_ONE="$TMPDIR/active-multi-chooser.json"
+MULTI_PROPOSAL_ONE="$TMPDIR/active-multi-proposal.json"
+write_session "$SESSION_ONE_MULTI_CANDIDATE" "$ROOT" "$DISCUSSION_ONE_MULTI_CANDIDATE"
+
+PI_COMPLETION_EXISTING_WORKFLOW_MISSION='Fix login redirect callback behavior.' \
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$MULTI_ROUTING_ONE" \
+PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$MULTI_CHOOSER_ONE" \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$MULTI_PROPOSAL_ONE" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_ONE_MULTI_CANDIDATE" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-active-multi.out" 2>"$TMPDIR/pi-completion-context-proposal-active-multi.err"
+
+python3 - "$MULTI_ROUTING_ONE" "$MULTI_CHOOSER_ONE" "$MULTI_PROPOSAL_ONE" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+selected = 'Fix login redirect callback behavior.'
+routing = json.loads(Path(sys.argv[1]).read_text())
+chooser = json.loads(Path(sys.argv[2]).read_text())
+proposal = json.loads(Path(sys.argv[3]).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())
+
+assert routing['action'] == 'unclear', 'multi-candidate replacement discussion should stay ambiguous until the chooser selects one mission'
+assert routing['reason'] == 'ambiguous_discussion', 'multi-candidate replacement discussion should record ambiguous-discussion routing'
+assert routing['alternateMissions'] == ['Fix login redirect callback behavior.'], 'routing snapshot should preserve alternate candidate missions'
+assert chooser['candidateMissions'] == ['Add logout redirect regression coverage.', 'Fix login redirect callback behavior.'], 'chooser snapshot should list the primary and alternate candidate missions'
+assert len(chooser['choices']) == 4, 'chooser should expose continue, primary, alternate, and cancel choices'
+assert 'Scope\n- Add coverage for logout redirect behavior.' in chooser['choices'][1], 'primary chooser option should summarize the candidate scope'
+assert 'Acceptance\n- Add a regression test for returning to the requested page.' in chooser['choices'][2], 'alternate chooser option should summarize the candidate acceptance'
+assert proposal['mission'] == selected, 'selected alternate mission should flow into the final proposal confirmation'
+assert state['mission_anchor'] == selected, 'selected alternate mission should rewrite state.json after approval'
+assert plan['mission_anchor'] == selected, 'selected alternate mission should rewrite plan.json after approval'
+assert active['mission_anchor'] == selected, 'selected alternate mission should rewrite active-slice.json after approval'
+PY
+
 # Active workflow: bare /cook with a placeholder planning mission should still route through the existing
 # refocus chooser and final Start/Cancel gate before canonical state is rewritten.
 SESSION_ONE_REFOCUS_NORMALIZED="$TMPDIR/session-one-refocus-normalized.jsonl"
@@ -747,10 +929,93 @@ assert plan['mission_anchor'] == mission, 'active bare /cook refocus should rewr
 assert active['mission_anchor'] == mission, 'active bare /cook refocus should rewrite active-slice.json only after approval'
 PY
 
-# Completed workflow: bare /cook should normalize placeholder planning phrasing for the next workflow
-# round too, not only for fresh startup.
+# Completed workflow: bare /cook should suppress proposals that simply restate the completed mission
+# without a clear reopen or next-round signal.
 mark_done
 
+SESSION_TWO_COMPLETED_SUPPRESS="$TMPDIR/session-two-completed-suppress.jsonl"
+CURRENT_DONE_MISSION="$(python3 - <<'PY'
+import json
+from pathlib import Path
+print(json.loads(Path('.agent/state.json').read_text())['mission_anchor'])
+PY
+)"
+DISCUSSION_TWO_COMPLETED_SUPPRESS="Mission: ${CURRENT_DONE_MISSION}
+Scope:
+- Keep the current completed mission exactly as-is.
+Constraints:
+- Do not start a different workflow from this discussion.
+Acceptance:
+- Keep the finished mission closed and unchanged."
+DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS="$TMPDIR/context-proposal-next-round-completed-suppress.json"
+write_session "$SESSION_TWO_COMPLETED_SUPPRESS" "$ROOT" "$DISCUSSION_TWO_COMPLETED_SUPPRESS"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_TWO_COMPLETED_SUPPRESS" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.out" "$TMPDIR/pi-completion-context-proposal-next-round-completed-suppress.err" "$DISCUSSION_SNAPSHOT_TWO_COMPLETED_SUPPRESS" "$CURRENT_DONE_MISSION" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+expected = sys.argv[4]
+state = json.loads(Path('.agent/state.json').read_text())
+
+assert state['mission_anchor'] == expected, 'completed-topic suppression should keep the done workflow mission anchor unchanged'
+assert state['continuation_policy'] == 'done', 'completed-topic suppression should keep the workflow closed'
+assert not snapshot.exists(), 'completed-topic suppression should not emit a proposal snapshot when the latest discussion only repeats finished work'
+assert '/cook failed closed' in output, 'completed-topic suppression should fail closed instead of reopening the finished mission'
+PY
+
+# Completed workflow: bare /cook should also suppress proposals that merely restate canonical
+# verification evidence for already verified work.
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+state = json.loads(Path('.agent/state.json').read_text())
+state['latest_verified_slice'] = 'verified-logout-redirect'
+Path('.agent/state.json').write_text(json.dumps(state, indent=2) + '\n')
+
+evidence = json.loads(Path('.agent/verification-evidence.json').read_text())
+evidence.update({
+    'subject_type': 'selected_slice',
+    'slice_id': 'verified-logout-redirect',
+    'goal': 'Add logout redirect regression coverage.',
+    'summary': 'Verified logout redirect regression coverage already matches the selected slice and current HEAD.',
+    'outcome': 'pass',
+})
+Path('.agent/verification-evidence.json').write_text(json.dumps(evidence, indent=2) + '\n')
+PY
+
+SESSION_TWO_VERIFIED_SUPPRESS="$TMPDIR/session-two-verified-suppress.jsonl"
+DISCUSSION_TWO_VERIFIED_SUPPRESS=$'Mission: Add logout redirect regression coverage.\nScope:\n- Add coverage for logout redirect behavior.\nConstraints:\n- Do not change the verified logout redirect work.\nAcceptance:\n- Keep the verified logout redirect regression coverage unchanged.'
+DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS="$TMPDIR/context-proposal-next-round-verified-suppress.json"
+write_session "$SESSION_TWO_VERIFIED_SUPPRESS" "$ROOT" "$DISCUSSION_TWO_VERIFIED_SUPPRESS"
+
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS" \
+PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
+pi --session "$SESSION_TWO_VERIFIED_SUPPRESS" -e "$PKG_ROOT" -p "/cook" >"$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.out" 2>"$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.err"
+
+python3 - "$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.out" "$TMPDIR/pi-completion-context-proposal-next-round-verified-suppress.err" "$DISCUSSION_SNAPSHOT_TWO_VERIFIED_SUPPRESS" <<'PY'
+import sys
+from pathlib import Path
+
+output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
+snapshot = Path(sys.argv[3])
+assert not snapshot.exists(), 'verification-evidence overlap suppression should not emit a proposal snapshot for already verified work'
+assert '/cook failed closed' in output, 'verification-evidence overlap suppression should fail closed when the latest discussion only repeats verified work'
+PY
+
+# Completed workflow: bare /cook should normalize placeholder planning phrasing for the next workflow
+# round too, not only for fresh startup.
 SESSION_TWO_NORMALIZED="$TMPDIR/session-two-normalized.jsonl"
 DISCUSSION_TWO_NORMALIZED=$'Mission: 開始實作這個方案\nScope:\n- Normalize bare /cook planning phrasing for the next workflow round.\n- Reset canonical state for the new implementation mission.\nConstraints:\n- Do not resume the completed workflow when the new round is clearly different.\nAcceptance:\n- Start a new round with the normalized mission anchor.'
 DISCUSSION_SNAPSHOT_TWO_NORMALIZED="$TMPDIR/context-proposal-next-round-normalized.json"