@linimin/pi-letscook 0.1.59 → 0.1.61

package/.agent/mission.md

@@ -3,6 +3,6 @@
 Project: pi-letscook
 
 Mission anchor:
-Implement the primary-agent → /cook handoff pipeline refactor so /cook only starts implementation workflow from structurally startable handoffs, while preserving explicit handoff as the preferred startup-intake path.
+Refactor the /cook startup boundary into the agreed mixed model: ordinary chat stays advisory-first by default with no default pre-/cook handoff capsule formation, while explicit /cook performs structured startup synthesis from recent discussion and preserves the approval-only Start/Cancel gate.
 
 This file is a tracked human-readable statement of the repo's completion mission. Re-grounders may refine this file when repo truth becomes clearer, but it must stay truthful to shipped behavior and the active completion objective.

package/CHANGELOG.md

@@ -2,14 +2,13 @@
 
 ## Unreleased
 
-## 0.1.59
+## 0.1.61
 
 ### Changed
 
-- relaxed the pre-`/cook` ordinary-chat boundary so the primary agent can keep discussing and refining requirements before explicit `/cook` instead of switching into a hard handoff-only refusal mode as soon as workflow-worthiness is detected
-- kept `/cook` as the only explicit workflow boundary, while teaching the pre-`/cook` prompt surfaces to recommend `/cook` advisory-first and only emit implementation-ready capsules once the first bounded slice is concrete enough
-- made fresh explicit `/cook` handoffs reusable from recent ordinary-chat discussion instead of requiring the immediately preceding turn, so Cancel can return users cleanly to ordinary discussion before they rerun `/cook`
-- kept bare `/cook` startup and done-workflow next-round entry fail-closed on missing or non-startable explicit handoffs, while active workflows still resume from canonical `.agent/**` state unless a fresh explicit handoff proposes replacement
+- removed proactive primary-agent `/cook` prompting and default ordinary-chat `cook_handoff` emission so main chat stays advisory until the user explicitly runs `/cook`
+- changed bare `/cook` startup and done-workflow next-round entry to synthesize a deferred primary-agent startup brief from recent discussion instead of requiring a pre-authored explicit handoff capsule
+- kept active-workflow bare `/cook` resumable from canonical `.agent/**` state by default while allowing `/cook` to confirm a concrete replacement mission derived from explicit entry context
 - updated public parity and shipped package contents so the tracked `.agent` contract files are included in package tarballs and packaged smoke/release verification can scaffold canonical state truthfully
 
 ## 0.1.58

package/README.md

@@ -30,10 +30,10 @@ Then run `/reload` in Pi.
 1. Install the package:
    `pi install npm:@linimin/pi-letscook`
 2. Run `/reload` in Pi.
-3. In the main chat, describe the concrete repo change you want and let the primary agent help refine it until the first slice is ready for `/cook`.
-4. Run `/cook`.
-5. Review the startup brief and choose **Start** or **Cancel**.
-6. Later, run `/cook` again to resume from canonical state or confirm an explicit replacement or next-round handoff.
+3. In the main chat, describe and refine the concrete repo change you want.
+4. When you want to enter workflow, run `/cook`.
+5. Review the synthesized startup brief and choose **Start** or **Cancel**.
+6. Later, run `/cook` again to resume from canonical state or confirm a synthesized replacement or next-round startup brief.
 
 ```text
 /cook
@@ -43,20 +43,20 @@ Then run `/reload` in Pi.
 
 | If you want to... | Do this |
 |---|---|
-| Start a long-running task | Discuss the concrete repo change in the main chat, wait for a fresh primary-agent handoff, then run `/cook` |
+| Start a long-running task | Discuss the concrete repo change in the main chat, then run `/cook` when you want workflow to begin |
 | Continue the current workflow | Run `/cook` |
-| Refocus or start the next round | Discuss the new concrete repo change in the main chat, wait for a fresh primary-agent handoff, then run `/cook` |
+| Refocus or start the next round | Discuss the new concrete repo change in the main chat, then run `/cook` when you want a new startup brief synthesized |
 
 ## What `/cook` expects
 
-- a fresh valid explicit primary-agent `/cook` handoff capsule from recent ordinary-chat discussion whenever `/cook` is starting a new workflow or the next round after a completed workflow
-- for that handoff capsule to start workflow immediately, it must already be implementation-startable: a bounded `first_slice_goal`, repo-change-oriented acceptance, `implementation_surfaces`, `verification_commands`, and `why_this_slice_first`
-- enough detail in the main chat for the primary agent to form that bounded handoff capsule before you run `/cook`
+- enough recent main-chat discussion for `/cook` to synthesize a concrete startup brief when you explicitly invoke it
+- a mission that is concrete enough to anchor bounded repo work rather than planning-only discussion
+- acceptance and verification intent that can support a truthful first workflow round
 - README/CHANGELOG updates still count as concrete repo changes
-- assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts still do not count unless they include the explicit structured `/cook` handoff capsule
-- recent main-chat discussion can still validate or supplement an accepted explicit handoff, but it no longer starts a new workflow by itself
+- assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts still do not count unless they can be turned into a concrete startup brief
+- optional explicit `cook_handoff` capsules may still be consumed as a compatibility intake path, but they are no longer required for new-workflow or next-round entry
 
-If no fresh valid handoff exists for new-workflow or next-round entry, `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to get an explicit primary-agent handoff in the main chat before rerunning `/cook`.
+If `/cook` cannot derive a concrete startup brief, it fails closed, leaves canonical `.agent/**` state unchanged, and tells you to refine the mission, first slice, or verification intent in the main chat before rerunning `/cook`.
 
 If a fresh explicit handoff exists but is still workflow-worthy rather than implementation-startable, `/cook` also fails closed instead of silently treating that capsule as planning support or canonical workflow state.
 
@@ -66,40 +66,38 @@ If you pass inline arguments to `/cook`, it also fails closed and tells you to m
 
 Only explicit `/cook` enters the workflow. Ordinary prompts stay in the main chat and go straight to the primary agent.
 
-If a task has clearly matured into completion-workflow scope, the primary agent should recommend `/cook` instead of starting long-running implementation directly in ordinary chat.
+If a task has clearly matured into completion-workflow scope, the primary agent should still avoid starting long-running implementation directly in ordinary chat.
 
-Before you explicitly run `/cook`, the conversation can still stay in ordinary chat: the primary agent may keep answering follow-up questions and refining requirements rather than switching into a hard handoff-only refusal mode.
+Ordinary chat remains advisory until you explicitly run `/cook`. At that point `/cook` synthesizes a startup brief from recent discussion using primary-agent-style context, then asks you to **Start** or **Cancel** before rewriting canonical workflow state.
 
-That handoff should include an explicit structured `/cook` capsule in the assistant reply once the first slice is implementation-ready, so `/cook` can confirm the already-formed mission instead of re-deriving it from broad ambient context.
-
-The capsule is still advisory startup intake, not canonical workflow state, and new-workflow or next-round entry only proceeds when it already names the first bounded slice, repo-change-oriented acceptance, implementation surfaces, and verification commands.
+Optional explicit `/cook` capsules may still be used as compatibility startup intake, but they are no longer the default path and are not required for new-workflow or next-round entry.
 
 Important behavior:
 - `/cook` is the canonical workflow boundary and manual entry point
-- startup and next-round entry stay confirm-first and require a fresh valid explicit primary-agent handoff
-- active workflows resume from canonical `.agent/**` state unless a fresh valid explicit handoff proposes a replacement
+- startup and next-round entry stay confirm-first, but they now derive startup from explicit user `/cook` entry plus recent discussion when needed
+- active workflows resume from canonical `.agent/**` state unless `/cook` synthesizes or receives a concrete replacement mission
 - explicit slash commands other than `/cook` continue normally in the main chat
-- ordinary main-chat discussion may clarify or propose, but mature long-running implementation should be handed off to `/cook`
+- ordinary main-chat discussion may clarify or propose, but mature long-running implementation still must not start before explicit `/cook`
 
 ## Typical examples
 
-Start a new workflow after a fresh primary-agent handoff:
+Start a new workflow from recent main-chat discussion:
 
 ```text
 I want to add login redirect handling and tests.
-# let the primary agent hand you off to /cook
+# discuss/refine in main chat
 /cook
 ```
 
 ## What happens when you run `/cook`
 
-`/cook` first looks for a fresh explicit primary-agent handoff capsule from recent ordinary-chat discussion. New-workflow entry and done-workflow next-round entry start only when that capsule is fresh, valid, and implementation-startable; otherwise `/cook` fails closed instead of deriving startup from recent discussion. When a workflow is already active and no fresh valid explicit handoff is present, `/cook` resumes from canonical `.agent/**` state instead of deriving replacement startup from recent discussion.
+`/cook` first checks for a fresh explicit primary-agent handoff capsule as a compatibility intake path. If none is present, `/cook` synthesizes a startup brief from recent discussion using primary-agent-style context. New-workflow entry and done-workflow next-round entry still fail closed when that synthesis is too weak or planning-only. When a workflow is already active and no concrete replacement mission is available, `/cook` resumes from canonical `.agent/**` state.
 
 | Repo state | What you'll see |
 |---|---|
-| No workflow yet | If a fresh explicit handoff capsule exists and is implementation-startable, you get a startup brief built from that handoff and choose **Start** or **Cancel**. Otherwise `/cook` fails closed, leaves canonical state unchanged, and tells you to get a fresh explicit primary-agent handoff. Weak, unreliable, stale, planning-only, or non-startable explicit-handoff intake also fails closed. |
-| Active workflow exists | Usually a resume of the current workflow from canonical `.agent/**` state. If a fresh explicit handoff capsule points to a different concrete repo change, `/cook` shows a chooser first and only rewrites canonical state after you confirm the replacement. Ambiguous intake stays conservative. |
-| Previous workflow is `done` | A fresh explicit handoff capsule can still start the next implementation round behind **Start** or **Cancel**. Without one, `/cook` fails closed instead of deriving the next round from recent discussion. |
+| No workflow yet | `/cook` synthesizes a startup brief from recent discussion and asks you to choose **Start** or **Cancel**. A fresh explicit handoff capsule may still be used if present. Weak, unreliable, stale, planning-only, or non-startable intake still fails closed. |
+| Active workflow exists | Usually a resume of the current workflow from canonical `.agent/**` state. If `/cook` finds a different concrete replacement mission from a compatibility capsule or deferred synthesis, it shows a chooser first and only rewrites canonical state after you confirm the replacement. Ambiguous intake stays conservative. |
+| Previous workflow is `done` | `/cook` can synthesize the next implementation round from recent discussion behind **Start** or **Cancel**. Weak or planning-only next-round intake still fails closed. |
 
 ## Confirmation and fail-closed behavior
 
@@ -107,9 +105,9 @@ I want to add login redirect handling and tests.
 
 - startup, next-round, and refocus proposals are approval-only
 - actions are **Start** and **Cancel**
-- **Cancel** is side-effect free: canonical workflow state stays unchanged, so you can discuss changes in the main chat and rerun `/cook`
+- **Cancel** is side-effect free: discuss changes in the main chat and rerun `/cook`
 - weak, ambiguous, stale, invalid, assistant-produced, or planning-only intake does not start a workflow
-- when a fresh explicit handoff suggests replacing an active workflow, `/cook` shows a chooser before any canonical state rewrite
+- when a concrete replacement mission suggests replacing an active workflow, `/cook` shows a chooser before any canonical state rewrite
 
 When you accept startup or refocus, `/cook` persists the chosen workflow state in canonical `.agent/**` files before the re-ground round begins.
 

package/extensions/completion/driver.ts

@@ -38,7 +38,7 @@ type ContextProposalAlternate = {
 	analysis: ContextProposalAnalysis;
 	goalText: string;
 	basisPreview: string;
-	source: "session" | "analyst" | "handoff_capsule";
+	source: "session" | "analyst" | "handoff_capsule" | "deferred_primary_agent_handoff";
 };
 
 type ContextProposal = ContextProposalAlternate & {
@@ -60,9 +60,8 @@ type CookContextProposalResult = {
 	blockedFailureMessage?: string;
 };
 
-function buildCookExplicitHandoffRequiredMessage(deps: CompletionDriverDeps, prefix?: string): string {
-	const requirement =
-		"/cook failed closed because starting a new completion workflow now requires a fresh valid explicit primary-agent handoff. Ask the primary agent to emit a fresh ```cook_handoff``` capsule in the main chat, then rerun /cook.";
+function buildCookStartupDerivationFailureMessage(deps: CompletionDriverDeps, prefix?: string): string {
+	const requirement = deps.structuredDiscussionFailureDetail;
 	return prefix ? `${prefix} ${requirement}` : requirement;
 }
 
@@ -73,9 +72,10 @@ type ActiveWorkflowProposalAssessment = {
 	blockedFailureMessage?: string;
 	reason:
 		| "matching_mission"
-		| "missing_explicit_handoff"
-		| "fresh_explicit_handoff"
-		| "fresh_explicit_handoff_not_startable";
+		| "no_replacement_proposal"
+		| "explicit_handoff_replacement"
+		| "deferred_replacement"
+		| "replacement_not_startable";
 };
 
 type ExistingWorkflowChooserOptions = {
@@ -321,23 +321,23 @@ async function assessActiveWorkflowProposalRouting(
 ): Promise<ActiveWorkflowProposalAssessment> {
 	const currentMission = currentMissionAnchor(snapshot);
 	const projectName = path.basename(snapshot.files.root);
-	const explicitHandoff = await deps.deriveCookStartupProposal(ctx, projectName);
-	if (explicitHandoff.blockedFailureMessage) {
+	const derived = await deps.deriveCookContextProposal(ctx, projectName);
+	if (derived.blockedFailureMessage) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "blocked",
 			currentMissionAnchor: currentMission,
-			blockedFailureMessage: explicitHandoff.blockedFailureMessage,
-			reason: "fresh_explicit_handoff_not_startable",
+			blockedFailureMessage: derived.blockedFailureMessage,
+			reason: "replacement_not_startable",
 		};
 		deps.maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 		return assessment;
 	}
-	const proposal = explicitHandoff.proposal;
+	const proposal = derived.proposal;
 	if (!proposal) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "continue",
 			currentMissionAnchor: currentMission,
-			reason: "missing_explicit_handoff",
+			reason: "no_replacement_proposal",
 		};
 		deps.maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 		return assessment;
@@ -356,7 +356,7 @@ async function assessActiveWorkflowProposalRouting(
 		action: "refocus",
 		currentMissionAnchor: currentMission,
 		proposal,
-		reason: "fresh_explicit_handoff",
+		reason: proposal.source === "handoff_capsule" ? "explicit_handoff_replacement" : "deferred_replacement",
 	};
 	deps.maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 	return assessment;
@@ -543,7 +543,7 @@ export async function runCookEntry(
 		}
 		const proposal = derived.proposal;
 		if (!proposal) {
-			deps.emitCommandText(ctx, buildCookExplicitHandoffRequiredMessage(deps), "info");
+			deps.emitCommandText(ctx, buildCookStartupDerivationFailureMessage(deps), "info");
 			return;
 		}
 		const decision = await deps.confirmContextProposal(ctx, proposal, {
@@ -588,7 +588,7 @@ export async function runCookEntry(
 			}
 			const proposal = derived.proposal;
 			if (!proposal) {
-				deps.emitCommandText(ctx, buildCookExplicitHandoffRequiredMessage(deps, "The previous completion workflow is already done."), "info");
+				deps.emitCommandText(ctx, buildCookStartupDerivationFailureMessage(deps, "The previous completion workflow is already done."), "info");
 				return;
 			}
 			const decision = await deps.confirmContextProposal(ctx, proposal, {
@@ -610,7 +610,13 @@ export async function runCookEntry(
 				buildAdvisoryStartupBrief({ proposal, analysis: decision.analysis }),
 			);
 			snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-			deps.emitCommandText(ctx, `Started a new completion workflow round from explicit primary-agent handoff: ${decision.missionAnchor}`, "info");
+			deps.emitCommandText(
+				ctx,
+				proposal.source === "handoff_capsule"
+					? `Started a new completion workflow round from explicit primary-agent handoff: ${decision.missionAnchor}`
+					: `Started a new completion workflow round from deferred primary-agent handoff: ${decision.missionAnchor}`,
+				"info",
+			);
 		} else {
 			const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, deps);
 			if (assessment.action === "blocked") {
@@ -621,20 +627,29 @@ export async function runCookEntry(
 				await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
 				return;
 			}
-			const explicitReplacement = assessment.reason === "fresh_explicit_handoff";
+			const explicitReplacement = assessment.reason === "explicit_handoff_replacement";
+			const deferredReplacement = assessment.reason === "deferred_replacement";
 			const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, deps, {
 				intro: explicitReplacement
 					? "A fresh explicit primary-agent handoff proposes replacing the current workflow. Choose how /cook should proceed:"
-					: "A replacement workflow is ready. Choose how /cook should proceed:",
+					: deferredReplacement
+						? "A deferred primary-agent handoff synthesized from your recent discussion proposes replacing the current workflow. Choose how /cook should proceed:"
+						: "A replacement workflow is ready. Choose how /cook should proceed:",
 				proposedMissionLabel: explicitReplacement
 					? "Proposed mission from explicit primary-agent handoff"
-					: "Proposed mission",
+					: deferredReplacement
+						? "Proposed mission from deferred primary-agent handoff"
+						: "Proposed mission",
 				refocusChoiceLabel: explicitReplacement
 					? "Start new workflow from explicit primary-agent handoff\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."
-					: "Start new workflow\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state.",
+					: deferredReplacement
+						? "Start new workflow from deferred primary-agent handoff\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."
+						: "Start new workflow\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state.",
 				alternateChoiceLabel: explicitReplacement
 					? "Start alternate workflow from explicit primary-agent handoff\n\nReview this alternate replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."
-					: undefined,
+					: deferredReplacement
+						? "Start alternate workflow from deferred primary-agent handoff\n\nReview this alternate replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state."
+						: undefined,
 				comparison: "strict",
 			});
 			if (!decision) {
@@ -647,9 +662,11 @@ export async function runCookEntry(
 			}
 			const selectedProposal = decision.proposal;
 			const proposalDecision = await deps.confirmContextProposal(ctx, selectedProposal, {
-				title: assessment.reason === "fresh_explicit_handoff"
+				title: explicitReplacement
 					? "Start the replacement workflow from this explicit startup brief?"
-					: "Start the replacement workflow from this startup brief?",
+					: deferredReplacement
+						? "Start the replacement workflow from this deferred startup brief?"
+						: "Start the replacement workflow from this startup brief?",
 			});
 			if (!proposalDecision) {
 				deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal", deps), "info");
@@ -669,9 +686,11 @@ export async function runCookEntry(
 			snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
 			deps.emitCommandText(
 				ctx,
-				assessment.reason === "fresh_explicit_handoff"
+				explicitReplacement
 					? `Refocused completion mission from explicit primary-agent handoff to: ${proposalDecision.missionAnchor}`
-					: `Refocused completion mission to: ${proposalDecision.missionAnchor}`,
+					: deferredReplacement
+						? `Refocused completion mission from deferred primary-agent handoff to: ${proposalDecision.missionAnchor}`
+						: `Refocused completion mission to: ${proposalDecision.missionAnchor}`,
 				"info",
 			);
 		}

package/extensions/completion/index.ts

@@ -25,6 +25,7 @@ import {
 	missionAnchorsStrictlyEquivalent,
 	normalizeMissionAnchorText,
 	resolveContextProposalConfirmationAction,
+	retagContextProposalSource,
 	stripCodeBlocks,
 } from "./proposal";
 import type {
@@ -107,6 +108,7 @@ type RubricEvaluationRole = (typeof RUBRIC_EVALUATION_ROLES)[number];
 const liveRoleActivityByRoot = new Map<string, LiveRoleActivity>();
 const activatedCompletionRoutingRoots = new Set<string>();
 const LIVE_ROLE_HEARTBEAT_MS = 5_000;
+const COOK_HANDOFF_BLOCK_REGEX = /```cook_handoff\s*[\s\S]*?```/giu;
 
 function asBoolean(value: unknown): boolean | undefined {
 	return typeof value === "boolean" ? value : undefined;
@@ -133,9 +135,10 @@ type ActiveWorkflowProposalAssessment = {
 	blockedFailureMessage?: string;
 	reason:
 		| "matching_mission"
-		| "missing_explicit_handoff"
-		| "fresh_explicit_handoff"
-		| "fresh_explicit_handoff_not_startable";
+		| "no_replacement_proposal"
+		| "explicit_handoff_replacement"
+		| "deferred_replacement"
+		| "replacement_not_startable";
 };
 
 function completionTestWorkflowActionOverride(): "continue" | "refocus" | "cancel" | undefined {
@@ -209,7 +212,7 @@ 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 =
-	"/cook failed closed because new-workflow startup now requires a fresh valid explicit primary-agent handoff from recent ordinary-chat discussion; recent discussion alone no longer starts a workflow. Ask the primary agent to hand off explicitly in the main chat, then rerun /cook.";
+	"/cook failed closed because it could not derive a concrete startup brief from recent discussion. Clarify the mission, first slice, or verification intent in the main chat, then rerun /cook.";
 
 function isWorkflowDone(snapshot: CompletionStateSnapshot | undefined): boolean {
 	return asString(snapshot?.state?.continuation_policy) === "done";
@@ -372,6 +375,72 @@ async function promptContextProposalConfirmationAction(
 	});
 }
 
+function stripCookHandoffBlocks(text: string): string {
+	return text.replace(COOK_HANDOFF_BLOCK_REGEX, " ").replace(/\s+/g, " ").trim();
+}
+
+async function deriveCookRecentDiscussionProposal(
+	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
+	projectName: string,
+): Promise<ContextProposal | undefined> {
+	const recentMessages = collectRecentSessionMessages(ctx, { isRecord, asString, asNumber, isStaleContextError });
+	const recentEntries = recentMessages
+		.filter((entry) => (entry.role === "user" || entry.role === "custom") && !entry.isCommand)
+		.filter((entry) => !/```cook_handoff\b/i.test(entry.text))
+		.slice(0, 8)
+		.map((entry) => ({ role: entry.role, text: stripCookHandoffBlocks(entry.text) }))
+		.filter((entry) => entry.text.length > 0);
+	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)"}`,
+		]
+		: [];
+	const proposal = 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,
+				getCtxCwd,
+				getCtxHasUI,
+				getCtxUi,
+			}),
+		assessMissionAnchor,
+		isWeakMissionAnchor,
+		missionAnchorsStrictlyEquivalent,
+		normalizeMissionAnchorText,
+		stripCodeBlocks,
+	});
+	return retagContextProposalSource(proposal, "deferred_primary_agent_handoff");
+}
+
 async function deriveCookStartupProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
@@ -390,70 +459,14 @@ async function deriveCookStartupProposal(
 	if (explicitHandoff.status === "fresh_but_not_startable") {
 		return { blockedFailureMessage: explicitHandoff.message };
 	}
-	return {};
+	return { proposal: await deriveCookRecentDiscussionProposal(ctx, projectName) };
 }
 
 async function deriveCookContextProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
 ): Promise<CookContextProposalResult> {
-	const recentMessages = collectRecentSessionMessages(ctx, { isRecord, asString, asNumber, isStaleContextError });
-	const recentEntries = recentMessages
-		.filter((entry) => (entry.role === "user" || entry.role === "custom") && !entry.isCommand)
-		.slice(0, 8)
-		.map((entry) => ({ role: entry.role, text: entry.text }));
-	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)"}`,
-		]
-		: [];
-	const explicitHandoff = await deriveCookStartupProposal(ctx, projectName);
-	if (explicitHandoff.proposal || explicitHandoff.blockedFailureMessage) return explicitHandoff;
-	return {
-		proposal: 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,
-					getCtxCwd,
-					getCtxHasUI,
-					getCtxUi,
-				}),
-			assessMissionAnchor,
-			isWeakMissionAnchor,
-			missionAnchorsStrictlyEquivalent,
-			normalizeMissionAnchorText,
-			stripCodeBlocks,
-		}),
-	};
+	return await deriveCookStartupProposal(ctx, projectName);
 }
 
 async function confirmContextProposal(
@@ -929,7 +942,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		structuredDiscussionFailureDetail: COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL,
 		mainChatRerunGuidance: COOK_MAIN_CHAT_RERUN_GUIDANCE,
 		cookCommandSpec: {
-			description: "/cook workflow: start a new workflow or next round only from a fresh recent explicit primary-agent handoff, resume the current workflow from canonical state, or confirm an explicit replacement from the explicit /cook command",
+			description: "/cook workflow: synthesize a startup brief when the user explicitly enters /cook, resume the current workflow from canonical state, or confirm a replacement mission from explicit /cook entry",
 		},
 		buildContextProposalContinuationReason,
 		completionKickoff,

package/extensions/completion/prompt-surfaces.ts

@@ -10,7 +10,7 @@ import type {
 
 export type AdvisoryStartupBrief = {
 	kind: "startup_brief";
-	source: "recent_discussion" | "primary_agent_handoff";
+	source: "recent_discussion" | "primary_agent_handoff" | "deferred_primary_agent_handoff";
 	confirmed: true;
 	captured_at: string;
 	goal_text: string;
@@ -27,18 +27,15 @@ export type AdvisoryStartupBrief = {
 export function buildCookHandoffBoundaryReminder(): string {
 	return [
 		"You are still in ordinary main chat before any explicit /cook workflow entry.",
-		"Use ordinary chat to clarify requirements, discuss tradeoffs, propose implementation approaches, and refine scope with the user.",
+		"Use ordinary chat to clarify requirements, discuss tradeoffs, propose implementation approaches, and refine scope naturally.",
 		"/cook is the only explicit entrypoint into long-running completion workflow.",
-		"When you judge that the task has matured into completion-workflow scope — for example the user has clearly shifted from exploration into implementation intent, you have just produced a concrete plan or proposal whose next step would naturally be implementation, or the task spans multiple files, steps, or verification surfaces — do not begin long-running product implementation in ordinary chat and do not edit tracked product files for that workflow-level task.",
-		"Instead, recommend /cook as the workflow boundary while keeping the conversation in ordinary chat until the user explicitly runs /cook.",
-		"If the user keeps asking follow-up questions or refining requirements before /cook, continue that ordinary-chat discussion normally instead of switching into a handoff-only refusal mode, but do not act as though /cook had already been invoked.",
-		"Distinguish a workflow-worthy handoff from an implementation-ready handoff: only emit the implementation-ready capsule when the first bounded implementation slice is concrete enough to start immediately.",
-		"If the task is workflow-worthy but that first slice is still vague, say that /cook will be the right next step once the first bounded slice is concrete enough, then keep refining in ordinary chat without emitting an implementation-ready capsule yet.",
-		"When handing off, explain that /cook can start a new workflow or next round only from a fresh valid explicit primary-agent handoff capsule from recent ordinary-chat discussion; otherwise it fails closed, while already-active workflows resume from canonical .agent state unless a fresh valid explicit handoff proposes replacement.",
-		"Once the task is implementation-ready, append one exact fenced block in the same assistant reply using ```cook_handoff ... ``` JSON with kind/source/handoff_kind plus mission, scope, constraints or non_goals, acceptance, risks, notes, captured_at, source_turn_id, first_slice_goal, first_slice_non_goals, implementation_surfaces, verification_commands, why_this_slice_first, and optional task_type/evaluation_profile/why_cook_now.",
-		"Use handoff_kind implementation_workflow_handoff for that implementation-ready capsule.",
-		"If later ordinary-chat discussion materially changes the startup brief before /cook runs, update or replace the capsule in a later assistant reply instead of pretending the workflow already started.",
-		"The capsule is startup intake for /cook only: do not present it as canonical .agent state, an active slice, or a persistent repo contract.",
+		"Do not proactively tell the user to run /cook just because a task looks workflow-worthy, and do not emit a ```cook_handoff``` capsule by default in ordinary chat.",
+		"Even when the task has matured into workflow-level implementation work, ordinary chat remains ordinary chat until the user explicitly runs /cook.",
+		"Before that explicit /cook entry, do not begin long-running product implementation in ordinary chat, do not edit tracked product files for that workflow-level task, and do not act as though /cook had already been invoked.",
+		"If the user asks follow-up questions or wants to keep refining scope, continue helping in ordinary chat instead of steering them into workflow mode.",
+		"Once the user explicitly runs /cook, /cook will synthesize a startup brief from recent discussion using primary-agent-style context, then show Start/Cancel confirmation before canonical workflow state is rewritten.",
+		"Only provide a preview startup brief or ```cook_handoff``` capsule in ordinary chat when the user explicitly asks for that preview behavior.",
+		"Any preview capsule is startup intake for /cook only: do not present it as canonical .agent state, an active slice, or a persistent repo contract.",
 		"If the task is still ordinary Q&A, lightweight brainstorming, or a tiny one-off fix, continue normally without forcing /cook.",
 	].join(" ");
 }
@@ -97,7 +94,12 @@ export function buildAdvisoryStartupBrief(args: {
 }): AdvisoryStartupBrief {
 	return {
 		kind: "startup_brief",
-		source: args.proposal.source === "handoff_capsule" ? "primary_agent_handoff" : "recent_discussion",
+		source:
+			args.proposal.source === "handoff_capsule"
+				? "primary_agent_handoff"
+				: args.proposal.source === "deferred_primary_agent_handoff"
+					? "deferred_primary_agent_handoff"
+					: "recent_discussion",
 		confirmed: true,
 		captured_at: args.capturedAt ?? new Date().toISOString(),
 		goal_text: args.proposal.goalText,

package/extensions/completion/proposal.ts

@@ -27,7 +27,7 @@ export type ContextProposalAlternate = {
 	analysis: ContextProposalAnalysis;
 	goalText: string;
 	basisPreview: string;
-	source: "session" | "analyst" | "handoff_capsule";
+	source: "session" | "analyst" | "handoff_capsule" | "deferred_primary_agent_handoff";
 };
 
 export type ContextProposal = ContextProposalAlternate & {
@@ -1246,6 +1246,7 @@ export function extractContextProposalFromStructuredSession(
 
 const COOK_HANDOFF_BLOCK_REGEX = /```cook_handoff\s*([\s\S]*?)```/giu;
 const COOK_HANDOFF_MAX_AGE_MS = 45 * 60 * 1000;
+const COOK_HANDOFF_MAX_LATER_NON_COMMAND_MESSAGES = 2;
 const COOK_HANDOFF_NEGATIVE_MISSION_REGEX =
 	/(?:\b(?:do not|don't|dont|not|never|avoid|skip|refuse|recognize that|suppress|ignore|block|prevent)\b|(?:不要|別|别|勿|禁止|避免|忽略|阻止))/iu;
 const COOK_HANDOFF_WORKFLOW_ONLY_ACCEPTANCE_REGEX =
@@ -1388,6 +1389,19 @@ function isStartableCookHandoffCapsule(
 	return cookHandoffStartabilityFailures(capsule, deps).length === 0;
 }
 
+function laterMessagesInvalidateCookHandoff(
+	laterMessages: RecentSessionMessage[],
+	deps: Pick<ProposalParseDeps, "stripCodeBlocks">,
+): boolean {
+	const laterNonCommandMessages = laterMessages.filter((entry) => !entry.isCommand);
+	if (laterNonCommandMessages.length > COOK_HANDOFF_MAX_LATER_NON_COMMAND_MESSAGES) return true;
+	return laterNonCommandMessages.some((entry) => {
+		if (entry.role === "summary") return false;
+		if (!hasRecentDiscussionImplementationIntent(entry.text, deps.stripCodeBlocks)) return false;
+		return true;
+	});
+}
+
 function cookHandoffIsFreshEnough(capsule: CookHandoffCapsule, laterMessages: RecentSessionMessage[]): boolean {
 	const capturedAtMs = Date.parse(capsule.captured_at);
 	if (!Number.isFinite(capturedAtMs)) return false;
@@ -1470,6 +1484,7 @@ export function assessLatestCookHandoffProposal(
 			const capsule = capsules[capsuleIndex];
 			const laterMessages = recentMessages.slice(0, index);
 			if (!cookHandoffIsFreshEnough(capsule, laterMessages)) continue;
+			if (laterMessagesInvalidateCookHandoff(laterMessages, deps)) continue;
 			const failures = cookHandoffStartabilityFailures(capsule, deps);
 			if (failures.length > 0) {
 				return {
@@ -1515,6 +1530,18 @@ export async function deriveCookContextProposalFromRecentDiscussion(
 	return undefined;
 }
 
+export function retagContextProposalSource(
+	proposal: ContextProposal | undefined,
+	source: ContextProposalAlternate["source"],
+): ContextProposal | undefined {
+	if (!proposal) return undefined;
+	return {
+		...proposal,
+		source,
+		alternateProposals: proposal.alternateProposals.map((alternate) => ({ ...alternate, source })),
+	};
+}
+
 export function resolveContextProposalConfirmationAction(
 	proposal: ContextProposal,
 	action: ContextProposalConfirmAction,