@linimin/pi-letscook 0.1.60 → 0.1.61

package/CHANGELOG.md

@@ -2,17 +2,14 @@
 
 ## Unreleased
 
-## 0.1.60
-
-## 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 moving default startup and done-workflow next-round synthesis to bare `/cook` from recent ordinary-chat discussion behind the existing **Start** / **Cancel** approval gate
-- kept pre-`/cook` previews or `cook_handoff` capsules opt-in only, non-canonical, and advisory until the user explicitly runs `/cook`; bare `/cook` no longer depends on a default prebuilt capsule for new-workflow startup
-- kept active workflows resuming from canonical `.agent/**` state unless a fresh explicit handoff proposes a replacement, so discussion-only context does not silently rewrite an in-progress workflow
-- updated public parity and packaged release verification so README/help/changelog/release-check all describe and gate the shipped mixed model truthfully, while still packaging the tracked `.agent` contract files
+- 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,22 +43,22 @@ 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, then run `/cook` once the recent discussion is specific enough for a startup brief. If you explicitly want a pre-`/cook` preview or capsule first, ask for one. |
+| 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, then run `/cook` to synthesize the next startup brief. Active-workflow replacement still stays explicit and confirm-first. |
+| 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
 
-- recent ordinary-chat discussion concrete enough for bare `/cook` to synthesize a startup brief for a new workflow or the next round after a completed workflow
-- enough repo-change detail for that startup brief to stay implementation-oriented once you review it behind **Start** or **Cancel**
+- 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 become canonical workflow state by themselves
-- any pre-`/cook` preview or `cook_handoff` capsule only when you explicitly ask for it; that preview stays advisory startup intake, not canonical `.agent/**` state
-- active-workflow replacement still stays conservative: `/cook` resumes from canonical state unless a fresh explicit handoff proposes a different concrete repo change and you confirm that replacement
+- 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 recent discussion is too weak, ambiguous, stale, or planning-only for new-workflow or next-round entry, `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to clarify the concrete repo change 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 you explicitly asked for a preview capsule and it is still workflow-worthy rather than implementation-startable, `/cook` also fails closed instead of silently treating that preview as planning support or canonical workflow state.
+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.
 
 If you pass inline arguments to `/cook`, it also fails closed and tells you to move that intent into the main chat before rerunning bare `/cook`.
 
@@ -66,41 +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.
 
-If you explicitly ask for a pre-`/cook` preview or capsule, the primary agent may provide one, but that preview is opt-in only and stays non-canonical until you later run `/cook` and choose **Start**.
-
-Bare `/cook` is still the canonical workflow boundary: it synthesizes the startup brief from recent ordinary-chat discussion at `/cook` time, then waits for **Start** or **Cancel** before any canonical `.agent/**` write.
+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: bare `/cook` synthesizes the startup brief from recent discussion, then waits for **Start** or **Cancel**
-- active workflows resume from canonical `.agent/**` state unless a fresh valid explicit handoff proposes a replacement
-- any pre-`/cook` preview or capsule is explicit-request-only and non-canonical
+- 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 from recent discussion:
+Start a new workflow from recent main-chat discussion:
 
 ```text
 I want to add login redirect handling and tests.
-# discuss scope until the startup brief is clear enough
+# discuss/refine in main chat
 /cook
 ```
 
 ## What happens when you run `/cook`
 
-When no workflow is active, bare `/cook` synthesizes a startup brief from recent ordinary-chat discussion and then waits for **Start** or **Cancel**. If recent discussion is too weak, ambiguous, stale, or planning-only, `/cook` fails closed instead of guessing. If you explicitly asked for a preview capsule first and that preview is fresh but still non-startable, `/cook` also fails closed instead of silently treating it as canonical state. When a workflow is already active and no fresh valid explicit replacement 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 | `/cook` synthesizes a startup brief from recent discussion and shows **Start** / **Cancel**. If recent discussion is too weak, ambiguous, stale, or planning-only, `/cook` fails closed and leaves canonical state unchanged. An explicit-request preview capsule can inform that startup brief, but it is still non-canonical until you choose **Start**. |
-| 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` | `/cook` synthesizes the next implementation round from recent discussion behind **Start** / **Cancel**. If that recent discussion is too weak or ambiguous, `/cook` fails closed and leaves the finished workflow state unchanged. |
+| 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
 
@@ -108,10 +105,9 @@ When no workflow is active, bare `/cook` synthesizes a startup brief from recent
 
 - 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
-- any pre-`/cook` preview or capsule is advisory only and never writes canonical workflow state by itself
-- 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.
 
@@ -264,7 +260,7 @@ npm run rubric-contract-test
 npm run release-check
 ```
 
-`npm run release-check` is the broad packaged-release verifier. It begins with `bash .agent/verify_completion_control_plane.sh`, so missing or stale `.agent/verification-evidence.json` parity fails closed before the broader suite runs, then asserts the shipped mixed-model `/cook` public parity surfaces in `README.md`, `CHANGELOG.md`, and the `/cook` help/fail-closed copy in `extensions/completion/index.ts`, reruns the startup/refocus/context checks — including the critique-aware `/cook` confirmation regression and the smoke auto-resume prompt path — includes deterministic canonical evidence artifact coverage and includes deterministic active-slice contract coverage plus observability coverage, evaluator calibration, and the rubric-contract regression, and finishes with `npm pack --dry-run`.
+`npm run release-check` is the broad packaged-release verifier. It begins with `bash .agent/verify_completion_control_plane.sh`, so missing or stale `.agent/verification-evidence.json` parity fails closed before the broader suite runs, then asserts the shipped `/cook` public parity surfaces in `README.md`, `CHANGELOG.md`, and the `/cook` help/fail-closed copy in `extensions/completion/index.ts`, reruns the startup/refocus/context checks — including the critique-aware `/cook` confirmation regression and the smoke auto-resume prompt path — includes deterministic canonical evidence artifact coverage and includes deterministic active-slice contract coverage plus observability coverage, evaluator calibration, and the rubric-contract regression, and finishes with `npm pack --dry-run`.
 
 The direct package-root verifier commands above intentionally self-isolate the repo-local extension when they shell back into `pi`, so you should not need to wrap them with `pi --no-extensions` even if `@linimin/pi-letscook` is also installed globally on the same machine.
 

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 buildCookStartupBriefRequiredMessage(deps: CompletionDriverDeps, prefix?: string): string {
-	const requirement =
-		"/cook failed closed because recent discussion did not produce a clear execution-ready startup brief with Mission/Scope/Constraints/Acceptance for concrete repo changes. Clarify the concrete repo changes in the main chat and 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;
@@ -536,14 +536,14 @@ export async function runCookEntry(
 	if (!snapshot) {
 		const root = findRepoRoot(cwd) ?? cwd;
 		const projectName = path.basename(root);
-		const derived = await deps.deriveCookContextProposal(ctx, projectName);
+		const derived = await deps.deriveCookStartupProposal(ctx, projectName);
 		if (derived.blockedFailureMessage) {
 			deps.emitCommandText(ctx, derived.blockedFailureMessage, "info");
 			return;
 		}
 		const proposal = derived.proposal;
 		if (!proposal) {
-			deps.emitCommandText(ctx, buildCookStartupBriefRequiredMessage(deps), "info");
+			deps.emitCommandText(ctx, buildCookStartupDerivationFailureMessage(deps), "info");
 			return;
 		}
 		const decision = await deps.confirmContextProposal(ctx, proposal, {
@@ -581,14 +581,14 @@ export async function runCookEntry(
 	if (!goal) {
 		if (workflowDone) {
 			const projectName = path.basename(snapshot.files.root);
-			const derived = await deps.deriveCookContextProposal(ctx, projectName);
+			const derived = await deps.deriveCookStartupProposal(ctx, projectName);
 			if (derived.blockedFailureMessage) {
 				deps.emitCommandText(ctx, derived.blockedFailureMessage, "info");
 				return;
 			}
 			const proposal = derived.proposal;
 			if (!proposal) {
-				deps.emitCommandText(ctx, buildCookStartupBriefRequiredMessage(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, {
@@ -614,7 +614,7 @@ export async function runCookEntry(
 				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 recent discussion: ${decision.missionAnchor}`,
+					: `Started a new completion workflow round from deferred primary-agent handoff: ${decision.missionAnchor}`,
 				"info",
 			);
 		} else {
@@ -627,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) {
@@ -653,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");
@@ -675,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 recent discussion did not produce a clear execution-ready startup brief for bare /cook with Mission/Scope/Constraints/Acceptance for concrete repo changes. Clarify the concrete repo changes in the main chat and rerun /cook; canonical workflow state is still only written after Start.";
+	"/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: synthesize an approval-gated startup brief from recent discussion for new-workflow or next-round entry, resume the current workflow from canonical state, or confirm an explicit active-workflow replacement",
+			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,19 +27,16 @@ 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 opt-in preview request: by default, do not emit a structured preview or cook_handoff capsule in ordinary chat once the task is concrete enough; recommend bare /cook instead.",
-		"If the task is workflow-worthy but the user still wants to refine scope before /cook, keep refining in ordinary chat without acting as though workflow already started.",
-		"When handing off, explain that bare /cook will synthesize a startup brief from recent ordinary-chat discussion for a new workflow or next round, while already-active workflows resume from canonical .agent state unless the user explicitly chooses a replacement path backed by a fresh valid explicit handoff.",
-		"If the user explicitly asks for a /cook preview or capsule before running /cook, you may 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 opt-in preview capsule.",
-		"If later ordinary-chat discussion materially changes the startup brief before /cook runs, update or replace the preview capsule in a later assistant reply instead of pretending the workflow already started.",
+		"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 or emitting an unsolicited preview capsule.",
+		"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,