@linimin/pi-letscook 0.1.50 → 0.1.51

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.1.51
+
+### Added
+
+- shipped assist-mode natural-language handoff that can offer to route `開始做`, `開始實作`, or `go ahead` style execution handoffs into the canonical `/cook` flow before the primary agent starts implementation work, while keeping `/cook` as the explicit workflow boundary and approval gate
+- added `bash ./scripts/cook-trigger-routing-test.sh` to `npm run release-check` so packaged release parity now covers the natural-language takeover path alongside the existing `/cook` startup/refocus/context regressions
+
+### Changed
+
+- streamlined the README into a more user-facing guide with a 30-second quick start, common actions table, clearer natural-language handoff expectations, and shorter `/cook` usage explanations
+
 ## 0.1.50
 
 ### Changed

package/README.md

@@ -1,30 +1,21 @@
 # @linimin/pi-letscook
 
-A Pi extension for long-running repo work.
+`/cook` turns main-chat discussion about concrete repo changes into a resumable repo workflow stored in repo-local `.agent/**` state.
 
-It gives you `/cook`: a discussion-driven workflow command that keeps mission, progress, and verification in repo-local `.agent/**` state instead of chat memory.
+Assist-mode natural-language handoff can also offer to enter that same `/cook` flow before the primary agent starts implementation work, but `/cook` remains the canonical workflow boundary.
 
-## Is this for you?
+## Use it when
 
-**Useful if your work needs to:**
-- continue across sessions
-- stay anchored to one mission
-- resume from repo state instead of chat memory
-- keep review, audit, and verification tied to the repo
+- work spans multiple sessions
+- you want one mission tracked in repo state instead of chat memory
+- you want clear continue / refocus / next-round behavior
+- you want review, audit, and verification tied to the repo
 
-**Probably overkill if you mostly do:**
-- one-off chat tasks
-- brainstorming
-- planning docs without immediate implementation
+## Skip it when
 
-## What you get
-
-- one command: `/cook`
-- repo-local canonical state in `.agent/**`
-- resumable long-running workflows
-- discussion-first startup, continue, refocus, and next-round routing
-- fail-closed guidance that sends you back to the main chat when the mission still needs clarification
-- deterministic verification, review, audit, and stop checks
+- you only need a one-off answer
+- you are brainstorming
+- you are writing planning docs but are not ready to start concrete repo changes
 
 ## Install
 
@@ -34,62 +25,94 @@ pi install npm:@linimin/pi-letscook
 
 Then run `/reload` in Pi.
 
-## Quick start
+## 30-second quick start
 
-`/cook` supports both bare discussion-driven startup and optional inline intent hints.
+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.
+4. Run `/cook` or `/cook <hint>`.
+5. Review the proposal and choose **Start** or **Cancel**.
+6. Later, run `/cook` again to continue, refocus, or start the next round.
 
 ```text
 /cook
 /cook login redirect
 ```
 
-Use `/cook` after you discuss the mission in the main chat.
+## Common actions
+
+| If you want to... | Do this |
+|---|---|
+| Start a long-running task | Discuss the concrete repo change in the main chat, then run `/cook` |
+| Bias mission detection toward one intent | Run `/cook <hint>` |
+| Hand off from discussion into the same `/cook` flow | Say `開始做`, `開始實作`, or `go ahead`, then accept the confirmation |
+| Continue the current workflow | Run `/cook` |
+| Use the canonical fallback when the natural-language trigger does not fire | Run `/cook` explicitly |
 
-What it can do:
-- start a brand-new workflow from recent discussion
-- continue the current workflow when recent discussion still matches it, or when discussion is too weak or ambiguous to justify a refocus
-- surface a conservative refocus chooser when recent discussion clearly points to a different workflow
-- start the next workflow round after the previous one is `done`
+## What `/cook` expects
 
-What it expects:
 - recent main-chat discussion about concrete repo changes
 - README/CHANGELOG updates still count as concrete repo changes
 - assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts do not
 
-`/cook <hint>` acts as a high-priority intent hint that helps proposal derivation interpret the recent discussion, but it still goes through the same fail-closed routing and approval-only Start/Cancel confirmation flow.
+`/cook <hint>` acts as a high-priority intent hint for interpreting recent discussion, but it does not bypass fail-closed behavior or the approval-only Start/Cancel confirmation flow.
 
-On startup and next-round flows, if recent discussion is missing, weak, ambiguous, assistant-produced, or only describes planning artifacts instead of concrete repo changes, `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to clarify the mission in the main chat before rerunning `/cook`.
+If recent discussion is missing, weak, ambiguous, assistant-produced, or only describes planning artifacts instead of concrete repo changes, `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to clarify the mission in the main chat before rerunning `/cook`.
 
-## How `/cook` works
+## Natural-language handoff (assist mode)
 
-`/cook` supports both bare discussion-driven startup and optional inline intent hints.
+After you have discussed a concrete repo change in the main chat, short execution handoff phrases such as `開始做`, `開始實作`, or `go ahead` can offer to enter the same `/cook` flow before the primary agent starts implementation work.
 
-| Repo state | `/cook` behavior |
-|---|---|
-| No workflow yet | Summarizes recent main-chat discussion into a startup proposal, weighting the latest clear implementation intent ahead of older background discussion. Optional `/cook <hint>` text is treated as a high-priority cue for how to interpret that discussion, not as an unconditional mission override. The result still 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 `/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. Optional `/cook <hint>` text biases that routing and candidate ranking toward the hinted implementation intent without bypassing the chooser or final confirmation. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. |
-| Previous workflow is `done` | Starts the next round from recent main-chat discussion, then asks for approval with **Start** or **Cancel**. Optional `/cook <hint>` text biases next-round proposal derivation toward the hinted intent while still preserving fail-closed behavior. 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 `/cook`. Recent discussion that only restates already-completed or already-verified work also fails closed instead of reopening the finished mission. |
+Important behavior:
+- the handoff is only a shortcut into `/cook`; `/cook` is still the canonical workflow boundary
+- it asks for confirmation before `/cook` takes over
+- if the trigger is unclear or unavailable, nothing is auto-started and you can run `/cook` explicitly
+- ordinary questions and explicit slash commands continue normally
 
-## Approval-only confirmation and fail-closed behavior
+## Typical examples
 
-All startup, next-round, and replacement proposals are **approval-only**:
+Start a new workflow from recent discussion:
 
-- the proposal body is shown separately from actions
-- actions are only **Start** and **Cancel**
-- **Cancel** is side-effect free: discuss changes in the main chat and rerun `/cook`
+```text
+I want to add login redirect handling and tests.
+/cook
+```
 
-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. Optional `/cook <hint>` text can bias proposal ranking, but it still fails closed when repo truth or recent discussion does not support a clear executable mission.
+Bias proposal derivation toward a specific intent:
 
-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:
+```text
+/cook login redirect
+```
 
-- **Continue current workflow**
-- **Start new workflow from recent discussion**
-- **Start alternate workflow from recent discussion** (when a second plausible mission exists)
-- **Cancel**
+Hand off from discussion into the same `/cook` flow:
 
-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.
+```text
+We should implement the natural-language routing path next.
+開始做
+```
+
+## What happens when you run `/cook`
+
+`/cook` supports both bare discussion-driven startup and optional inline intent hints. Assist-mode natural-language handoff is optional; explicit `/cook` is always the canonical fallback.
+
+| Repo state | What you'll see |
+|---|---|
+| No workflow yet | A startup proposal built from recent main-chat discussion. You choose **Start** or **Cancel**. Weak or planning-only discussion fails closed. |
+| Active workflow exists | Usually a resume of the current workflow. If recent discussion clearly points to a different concrete repo change, `/cook` shows a chooser first and only rewrites canonical state after confirmation. Ambiguous discussion stays conservative. |
+| Previous workflow is `done` | A next-round proposal from recent main-chat discussion, again behind **Start** or **Cancel**. Discussion that only restates already-finished work fails closed. |
+
+## Confirmation and fail-closed behavior
 
-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.
+`/cook` never silently starts or rewrites canonical `.agent/**` state on unclear input.
+
+- startup, next-round, and refocus proposals are approval-only
+- actions are **Start** and **Cancel**
+- **Cancel** is side-effect free: discuss changes in the main chat and rerun `/cook`
+- weak, ambiguous, assistant-produced, or planning-only discussion does not start a workflow
+- when recent discussion suggests a different 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.
 
 ## Observability
 
@@ -109,6 +132,10 @@ While a `completion_role` subprocess is running:
 - running-role output distinguishes tool work from `PROGRESS`, `RATIONALE`, `NEXT`, `VERIFYING`, and `STATE-DELTA`
 - waiting and stalled states are surfaced deterministically from timestamps
 
+## Maintainer and protocol details
+
+The sections below are mainly useful if you maintain the extension, inspect canonical `.agent/**` state, or work on the packaged completion protocol itself.
+
 ## Structured evaluation rubrics
 
 The packaged completion workflow now defines a shared structured evaluation-rubric contract for the read-only evaluation roles:
@@ -225,6 +252,7 @@ Run validation from the package root:
 npm run smoke-test
 npm run refocus-test
 npm run context-proposal-test
+bash ./scripts/cook-trigger-routing-test.sh
 bash scripts/canonical-evidence-artifact-test.sh
 npm run observability-status-test
 npm run evaluator-calibration-test
@@ -232,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 single-command `/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 single-command `/cook` public parity surfaces in `README.md`, `CHANGELOG.md`, and the `/cook` help/fail-closed copy in `extensions/completion/index.ts`, reruns `bash ./scripts/cook-trigger-routing-test.sh` for the assist-mode natural-language handoff path, 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

@@ -530,142 +530,162 @@ function buildMission(projectName: string, missionAnchor: string): string {
 	return `# Mission\n\nProject: ${projectName}\n\nMission anchor:\n${missionAnchor}\n\nThis 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.\n`;
 }
 
-export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps): void {
-	pi.registerCommand("cook", {
-		description: deps.cookCommandSpec.description,
-		handler: async (args, ctx) => {
-			const explicitHint = args.trim().length > 0 ? args.trim() : undefined;
-			let goal: string | undefined;
-			const cwd = deps.getCtxCwd(ctx);
-			let snapshot = await loadCompletionSnapshot(cwd);
-			const workflowDone = isWorkflowDone(snapshot);
-			let kickoffIntent: "auto" | "continue" | "refocus" = "auto";
-			let kickoffMissionAnchor = snapshot ? currentMissionAnchor(snapshot) : undefined;
-			let kickoffAnalysis: ContextProposalAnalysis | undefined;
-
-			if (!snapshot) {
-				const root = findRepoRoot(cwd) ?? cwd;
-				const projectName = path.basename(root);
-				const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
-				if (!proposal) {
-					deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps), "info");
-					return;
-				}
-				const decision = await deps.confirmContextProposal(ctx, proposal, {
-					title: "Start a completion workflow from the recent discussion?",
-				});
-				if (!decision) {
-					deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal", deps), "info");
-					return;
-				}
-				goal = decision.goalText;
-				kickoffMissionAnchor = decision.missionAnchor;
-				kickoffAnalysis = decision.analysis;
-				const startupRouting = deps.finalizeContextProposalAnalysis(kickoffAnalysis, [goal ?? kickoffMissionAnchor ?? projectName]);
-				const created = await deps.scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName, {
-					analysis: startupRouting,
-					continuationReason: deps.buildContextProposalContinuationReason(
-						"User started workflow via /cook:",
-						goal ?? kickoffMissionAnchor ?? projectName,
-						startupRouting,
-					),
-				});
-				deps.emitCommandText(
-					ctx,
-					`Initialized completion control plane in ${created.root}${created.created.length > 0 ? ` (${created.created.length} files created)` : ""}`,
-					"info",
-				);
-				snapshot = await loadCompletionSnapshot(root);
+export type CookInvocationOrigin = "command" | "natural-language-trigger";
+
+export type RunCookEntryOptions = {
+	origin: CookInvocationOrigin;
+	hintText?: string;
+	originalInput?: string;
+};
+
+export async function runCookEntry(
+	pi: ExtensionAPI,
+	ctx: DriverContext,
+	deps: CompletionDriverDeps,
+	options: RunCookEntryOptions,
+): Promise<void> {
+	const explicitHint = options.hintText?.trim() ? options.hintText.trim() : undefined;
+	let goal: string | undefined;
+	const cwd = deps.getCtxCwd(ctx);
+	let snapshot = await loadCompletionSnapshot(cwd);
+	const workflowDone = isWorkflowDone(snapshot);
+	let kickoffIntent: "auto" | "continue" | "refocus" = "auto";
+	let kickoffMissionAnchor = snapshot ? currentMissionAnchor(snapshot) : undefined;
+	let kickoffAnalysis: ContextProposalAnalysis | undefined;
+
+	if (!snapshot) {
+		const root = findRepoRoot(cwd) ?? cwd;
+		const projectName = path.basename(root);
+		const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
+		if (!proposal) {
+			deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps), "info");
+			return;
+		}
+		const decision = await deps.confirmContextProposal(ctx, proposal, {
+			title: "Start a completion workflow from the recent discussion?",
+		});
+		if (!decision) {
+			deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal", deps), "info");
+			return;
+		}
+		goal = decision.goalText;
+		kickoffMissionAnchor = decision.missionAnchor;
+		kickoffAnalysis = decision.analysis;
+		const startupRouting = deps.finalizeContextProposalAnalysis(kickoffAnalysis, [goal ?? kickoffMissionAnchor ?? projectName]);
+		const created = await deps.scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName, {
+			analysis: startupRouting,
+			continuationReason: deps.buildContextProposalContinuationReason(
+				"User started workflow via /cook:",
+				goal ?? kickoffMissionAnchor ?? projectName,
+				startupRouting,
+			),
+		});
+		deps.emitCommandText(
+			ctx,
+			`Initialized completion control plane in ${created.root}${created.created.length > 0 ? ` (${created.created.length} files created)` : ""}`,
+			"info",
+		);
+		snapshot = await loadCompletionSnapshot(root);
+	}
+	if (!snapshot) {
+		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);
+			const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
+			if (!proposal) {
+				deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps, "The previous completion workflow is already done."), "info");
+				return;
 			}
-			if (!snapshot) {
-				deps.emitCommandText(ctx, "Failed to load completion workflow state", "error");
+			const decision = await deps.confirmContextProposal(ctx, proposal, {
+				title: "The previous completion workflow is done. Start the next workflow round from the recent discussion?",
+			});
+			if (!decision) {
+				deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal", deps), "info");
 				return;
 			}
-			deps.activateCompletionRoutingForRoot(snapshot.files.root);
-			if (!goal) {
-				if (workflowDone) {
-					const projectName = path.basename(snapshot.files.root);
-					const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
-					if (!proposal) {
-						deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps, "The previous completion workflow is already done."), "info");
-						return;
-					}
-					const decision = await deps.confirmContextProposal(ctx, proposal, {
-						title: "The previous completion workflow is done. Start the next workflow round from the recent discussion?",
-					});
-					if (!decision) {
-						deps.emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal", deps), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffIntent = "refocus";
-					kickoffMissionAnchor = decision.missionAnchor;
-					await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText, decision.analysis, deps);
-					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-					deps.emitCommandText(ctx, `Started a new completion workflow round from recent discussion: ${decision.missionAnchor}`, "info");
-				} else {
-					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, deps, explicitHint);
-					if (!assessment.proposal || assessment.action === "continue") {
-						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
-						return;
-					}
-					const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, deps, {
-						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");
-						return;
-					}
-					if (decision.action === "continue") {
-						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
-						return;
-					}
-					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");
-						return;
-					}
-					goal = proposalDecision.goalText;
-					kickoffIntent = "refocus";
-					kickoffMissionAnchor = proposalDecision.missionAnchor;
-					await refocusCompletionMission(snapshot, proposalDecision.missionAnchor, proposalDecision.goalText, proposalDecision.analysis, deps);
-					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-					deps.emitCommandText(ctx, `Refocused completion mission from recent discussion to: ${proposalDecision.missionAnchor}`, "info");
-				}
+			goal = decision.goalText;
+			kickoffIntent = "refocus";
+			kickoffMissionAnchor = decision.missionAnchor;
+			await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText, decision.analysis, deps);
+			snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
+			deps.emitCommandText(ctx, `Started a new completion workflow round from recent discussion: ${decision.missionAnchor}`, "info");
+		} else {
+			const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, deps, explicitHint);
+			if (!assessment.proposal || assessment.action === "continue") {
+				await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
+				return;
+			}
+			const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, deps, {
+				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");
+				return;
+			}
+			if (decision.action === "continue") {
+				await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
+				return;
+			}
+			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");
+				return;
 			}
-			kickoffMissionAnchor = kickoffMissionAnchor ?? currentMissionAnchor(snapshot);
-			const kickoffGoal = goal ?? kickoffMissionAnchor;
-			pi.setSessionName(`completion: ${kickoffMissionAnchor.slice(0, 60)}`);
-			const kickoffPrompt = deps.completionKickoff(
-				kickoffGoal,
-				currentTaskType(snapshot) ?? "(missing)",
-				currentEvaluationProfile(snapshot) ?? "(missing)",
-				kickoffIntent,
-				kickoffMissionAnchor,
-			);
-			const rootKey = deps.completionRootKey(snapshot, deps.getCtxCwd(ctx));
-			const fingerprint = completionContinuationFingerprint(snapshot) ?? JSON.stringify({
-				kind: "kickoff",
-				mission_anchor: kickoffMissionAnchor,
-				goal: kickoffGoal,
-				intent: kickoffIntent,
-				task_type: currentTaskType(snapshot) ?? "(missing)",
-				evaluation_profile: currentEvaluationProfile(snapshot) ?? "(missing)",
+			goal = proposalDecision.goalText;
+			kickoffIntent = "refocus";
+			kickoffMissionAnchor = proposalDecision.missionAnchor;
+			await refocusCompletionMission(snapshot, proposalDecision.missionAnchor, proposalDecision.goalText, proposalDecision.analysis, deps);
+			snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
+			deps.emitCommandText(ctx, `Refocused completion mission from recent discussion to: ${proposalDecision.missionAnchor}`, "info");
+		}
+	}
+	kickoffMissionAnchor = kickoffMissionAnchor ?? currentMissionAnchor(snapshot);
+	const kickoffGoal = goal ?? kickoffMissionAnchor;
+	pi.setSessionName(`completion: ${kickoffMissionAnchor.slice(0, 60)}`);
+	const kickoffPrompt = deps.completionKickoff(
+		kickoffGoal,
+		currentTaskType(snapshot) ?? "(missing)",
+		currentEvaluationProfile(snapshot) ?? "(missing)",
+		kickoffIntent,
+		kickoffMissionAnchor,
+	);
+	const rootKey = deps.completionRootKey(snapshot, deps.getCtxCwd(ctx));
+	const fingerprint = completionContinuationFingerprint(snapshot) ?? JSON.stringify({
+		kind: "kickoff",
+		mission_anchor: kickoffMissionAnchor,
+		goal: kickoffGoal,
+		intent: kickoffIntent,
+		task_type: currentTaskType(snapshot) ?? "(missing)",
+		evaluation_profile: currentEvaluationProfile(snapshot) ?? "(missing)",
+	});
+	await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, kickoffPrompt, "kickoff", deps);
+}
+
+export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps): void {
+	pi.registerCommand("cook", {
+		description: deps.cookCommandSpec.description,
+		handler: async (args, ctx) => {
+			await runCookEntry(pi, ctx, deps, {
+				origin: "command",
+				hintText: args,
 			});
-			await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, kickoffPrompt, "kickoff", deps);
 		},
 	});
 }

package/extensions/completion/index.ts

@@ -14,6 +14,7 @@ import {
 	markQueuedDriverPromptInFlight,
 	registerCookCommand,
 } from "./driver";
+import { handleCookNaturalLanguageTrigger } from "./input-routing";
 import {
 	assessMissionAnchor,
 	collectRecentDiscussionEntries,
@@ -207,9 +208,9 @@ function maybeWriteTestSnapshot(targetPath: string | undefined, content: string)
 
 const COOK_MAIN_CHAT_RERUN_GUIDANCE = "Discuss changes in the main chat and rerun /cook.";
 const COOK_BARE_ONLY_GUIDANCE =
-	"/cook supports optional inline hints as high-priority intent cues, but mission selection still comes from recent discussion, repo truth, and the approval-only confirmation flow.";
+	"/cook remains the canonical workflow boundary. Assist-mode natural-language handoff can offer to enter the same /cook flow before implementation starts, while mission selection still comes from recent discussion, repo truth, and the approval-only confirmation flow.";
 const COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL =
-	"/cook failed closed because recent discussion did not produce a clear execution-ready Mission/Scope/Constraints/Acceptance proposal for concrete repo changes. Clarify the concrete repo changes in the main chat and rerun /cook.";
+	"/cook failed closed because recent discussion did not produce a clear execution-ready Mission/Scope/Constraints/Acceptance proposal for concrete repo changes. Natural-language handoff only offers to enter the same /cook flow, so clarify the concrete repo changes in the main chat and rerun /cook.";
 
 function buildCookCancellationMessage(prefix: string): string {
 	return `${prefix}. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
@@ -922,7 +923,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		structuredDiscussionFailureDetail: COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL,
 		mainChatRerunGuidance: COOK_MAIN_CHAT_RERUN_GUIDANCE,
 		cookCommandSpec: {
-			description: "/cook workflow: start, continue, refocus, or start the next round (optional hint supported)",
+			description: "/cook workflow: start, continue, refocus, or start the next round; assist-mode natural-language handoff can offer the same /cook boundary",
 		},
 		buildContextProposalContinuationReason,
 		completionKickoff,
@@ -952,6 +953,10 @@ export default function completionExtension(pi: ExtensionAPI) {
 		shouldTreatBareActiveWorkflowProposalAsClearRefocus,
 	};
 
+	pi.on("input", async (event, ctx) => {
+		return await handleCookNaturalLanguageTrigger(pi, event, ctx, driverDeps);
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
 		await refreshCompletionStatus({ ctx, ...statusSurfaceArgs });
 		if (shouldTestAutoContinueOnSessionStart()) {