@linimin/pi-letscook 0.1.47 → 0.1.49

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.1.49
+
+### Changed
+
+- restored optional `/cook <hint>` support as a soft intent hint that biases context analysis, proposal ranking, active-workflow disambiguation, and next-round startup without bypassing fail-closed routing or the approval-only Start/Cancel gate
+
+## 0.1.48
+
+### Fixed
+
+- stopped injecting active completion workflow routing into ordinary non-`/cook` main-chat turns after a repo had been activated earlier in the same Pi process, so stale canonical stop-wave state can no longer pull unrelated user requests into `completion-regrounder` unless a fresh `/cook` driver prompt is actually in flight
+
 ## 0.1.47
 
 ### Changed

package/README.md

@@ -38,26 +38,26 @@ Primary entrypoint:
 /cook
 ```
 
-Use bare `/cook` after you discuss the mission in the main chat. The same command can:
+Use `/cook` after you discuss the mission in the main chat. You can run it bare or pass a short hint such as `/cook login redirect`. The same command can:
 
 - 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`
 
-`/cook` expects recent main-chat discussion to describe concrete repo changes. README/CHANGELOG updates still count as concrete repo changes, but assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts do not. `/cook <text>` is no longer supported; put mission text in the main chat, then rerun bare `/cook`.
+`/cook` expects recent main-chat discussion to describe concrete repo changes. README/CHANGELOG updates still count as concrete repo changes, but 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.
 
 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`.
 
 ## How `/cook` works
 
-Bare `/cook` is the only supported workflow entrypoint.
+`/cook` supports both bare discussion-driven startup and optional inline intent hints.
 
 | 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, then asks for approval with **Start** or **Cancel**. If the discussion is weak, ambiguous, assistant-produced, or only a plan/spec/design-doc/proposal artifact instead of concrete repo changes, `/cook` fails closed without writing `.agent/**` state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. |
-| Active workflow exists | Reads the current mission plus recent non-command main-chat discussion. Matching or unclear discussion resumes from canonical `.agent/**` state. Clear replacement discussion about different concrete repo changes opens a chooser first, then only rewrites canonical state after the follow-on **Start** confirmation. If recent discussion implies more than one plausible replacement mission, `/cook` keeps the current workflow parked behind a multi-candidate chooser instead of silently resuming or guessing. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. `/cook <text>` is rejected without running proposal routing or rewriting workflow state. |
-| Previous workflow is `done` | Starts the next round from recent main-chat discussion, then asks for approval with **Start** or **Cancel**. Weak, ambiguous, assistant-produced, or planning-artifact-only discussion fails closed without rewriting canonical state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. Recent discussion that only restates already-completed or already-verified work also fails closed instead of reopening the finished mission. `/cook <text>` is rejected before any next-round proposal is derived. |
+| 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. |
 
 ## Approval-only confirmation and fail-closed behavior
 
@@ -67,7 +67,7 @@ All startup, next-round, and replacement proposals are **approval-only**:
 - actions are only **Start** and **Cancel**
 - **Cancel** is side-effect free: discuss changes in the main chat and rerun `/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. `/cook <text>` also fails closed immediately and tells you to move that text into the main chat before rerunning bare `/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.
 
 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:
 

package/extensions/completion/driver.ts

@@ -106,7 +106,7 @@ export type CompletionDriverDeps = {
 		missionAnchor?: string,
 	) => string;
 	completionResumePrompt: (taskType: string, evaluationProfile: string) => string;
-	deriveCookContextProposal: (ctx: DriverContext, projectName: string) => Promise<ContextProposal | undefined>;
+	deriveCookContextProposal: (ctx: DriverContext, projectName: string, hintText?: string) => Promise<ContextProposal | undefined>;
 	confirmContextProposal: (
 		ctx: { hasUI: boolean; ui: any },
 		proposal: ContextProposal,
@@ -325,10 +325,11 @@ async function assessActiveWorkflowProposalRouting(
 	ctx: DriverContext,
 	snapshot: CompletionStateSnapshot,
 	deps: CompletionDriverDeps,
+	hintText?: string,
 ): Promise<ActiveWorkflowProposalAssessment> {
 	const currentMission = currentMissionAnchor(snapshot);
 	const projectName = path.basename(snapshot.files.root);
-	const proposal = await deps.deriveCookContextProposal(ctx, projectName);
+	const proposal = await deps.deriveCookContextProposal(ctx, projectName, hintText);
 	if (!proposal) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "unclear",
@@ -533,10 +534,7 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 	pi.registerCommand("cook", {
 		description: deps.cookCommandSpec.description,
 		handler: async (args, ctx) => {
-			if (args.trim().length > 0) {
-				deps.emitCommandText(ctx, deps.bareOnlyGuidance, "info");
-				return;
-			}
+			const explicitHint = args.trim().length > 0 ? args.trim() : undefined;
 			let goal: string | undefined;
 			const cwd = deps.getCtxCwd(ctx);
 			let snapshot = await loadCompletionSnapshot(cwd);
@@ -548,7 +546,7 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 			if (!snapshot) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
-				const proposal = await deps.deriveCookContextProposal(ctx, projectName);
+				const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
 				if (!proposal) {
 					deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps), "info");
 					return;
@@ -587,7 +585,7 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 			if (!goal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = await deps.deriveCookContextProposal(ctx, projectName);
+					const proposal = await deps.deriveCookContextProposal(ctx, projectName, explicitHint);
 					if (!proposal) {
 						deps.emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(deps, "The previous completion workflow is already done."), "info");
 						return;
@@ -606,7 +604,7 @@ export function registerCookCommand(pi: ExtensionAPI, deps: CompletionDriverDeps
 					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);
+					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, deps, explicitHint);
 					if (!assessment.proposal || assessment.action === "continue") {
 						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot, deps);
 						return;

package/extensions/completion/index.ts

@@ -207,7 +207,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_BARE_ONLY_GUIDANCE =
-	"/cook only supports the bare /cook entrypoint. Move mission text into the main chat, then rerun /cook.";
+	"/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.";
 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.";
 
@@ -242,8 +242,19 @@ function hasCompletionRoutingActivation(snapshot: CompletionStateSnapshot | unde
 	return activatedCompletionRoutingRoots.has(path.resolve(snapshot.files.root));
 }
 
-function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined): boolean {
-	return hasCompletionRoutingActivation(snapshot);
+function latestUserOrCustomTurnText(ctx: { sessionManager?: any }): string | undefined {
+	return collectRecentDiscussionEntries(ctx as { sessionManager: any }, { isRecord, asString, isStaleContextError }, 1)[0]?.text;
+}
+
+function isCompletionDriverPromptTurn(ctx: { sessionManager?: any }): boolean {
+	const latest = latestUserOrCustomTurnText(ctx);
+	if (!latest) return false;
+	if (!/^\/skill:completion-protocol\b/.test(latest)) return false;
+	return /(?:Start or continue the completion workflow for this repo\.|Resume the completion workflow from canonical state\.)/.test(latest);
+}
+
+function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined, ctx: { sessionManager?: any }): boolean {
+	return hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx);
 }
 
 function buildDoneWorkflowBoundaryReminder(snapshot: CompletionStateSnapshot): string {
@@ -366,6 +377,7 @@ async function promptContextProposalConfirmationAction(
 async function deriveCookContextProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
+	hintText?: string,
 ): Promise<ContextProposal | undefined> {
 	const recentEntries = collectRecentDiscussionEntries(ctx, { isRecord, asString, isStaleContextError });
 	const snapshot = await loadCompletionSnapshot(getCtxCwd(ctx));
@@ -381,9 +393,11 @@ async function deriveCookContextProposal(
 			`verification summary: ${asString(snapshot.verificationEvidence?.summary) ?? "(none)"}`,
 		]
 		: [];
+	if (hintText) workflowContextLines.push(`cook hint: ${hintText}`);
 	return await deriveCookContextProposalFromRecentDiscussion(projectName, recentEntries, {
 		asString,
 		asStringArray,
+		hintText,
 		workflowContext: snapshot
 			? {
 				currentMissionAnchor:
@@ -397,12 +411,15 @@ async function deriveCookContextProposal(
 				continuationPolicy: asString(snapshot.state?.continuation_policy),
 			}
 			: undefined,
-		analyzeContextProposal: async (entries) =>
+		analyzeContextProposal: async (entries, derivedHintText) =>
 			await analyzeContextProposalWithAgent({
 				ctx,
 				projectName,
 				recentEntries: entries,
-				workflowContextLines,
+				workflowContextLines:
+					derivedHintText && !workflowContextLines.includes(`cook hint: ${derivedHintText}`)
+						? [...workflowContextLines, `cook hint: ${derivedHintText}`]
+						: workflowContextLines,
 				liveRoleActivityByRoot,
 				completionStatusKey: COMPLETION_STATUS_KEY,
 				safeUiCall,
@@ -905,7 +922,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		structuredDiscussionFailureDetail: COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL,
 		mainChatRerunGuidance: COOK_MAIN_CHAT_RERUN_GUIDANCE,
 		cookCommandSpec: {
-			description: "Bare /cook workflow: start, continue, refocus, or start the next round",
+			description: "/cook workflow: start, continue, refocus, or start the next round (optional hint supported)",
 		},
 		buildContextProposalContinuationReason,
 		completionKickoff,
@@ -939,7 +956,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		await refreshCompletionStatus({ ctx, ...statusSurfaceArgs });
 		if (shouldTestAutoContinueOnSessionStart()) {
 			const snapshot = await loadCompletionSnapshot(getCtxCwd(ctx));
-			if (hasCompletionRoutingActivation(snapshot)) {
+			if (hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx)) {
 				await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
 			}
 		}
@@ -955,19 +972,20 @@ export default function completionExtension(pi: ExtensionAPI) {
 			await fsp.rm(snapshot.files.compactionMarkerPath, { force: true });
 		}
 		await refreshCompletionStatus({ ctx, ...statusSurfaceArgs });
-		if (hasCompletionRoutingActivation(snapshot)) {
+		if (hasCompletionRoutingActivation(snapshot) && isCompletionDriverPromptTurn(ctx)) {
 			await autoContinueWorkflowIfNeeded(pi, ctx, driverDeps);
 		}
 	});
 
 	pi.on("before_agent_start", async (_event, ctx) => {
 		const loaded = await loadCompletionDataForReminder(getCtxCwd(ctx));
-		if (loaded) {
+		const driverPromptTurn = isCompletionDriverPromptTurn(ctx);
+		if (loaded && driverPromptTurn) {
 			const rootKey = completionRootKey(loaded.snapshot, getCtxCwd(ctx));
 			const fingerprint = completionContinuationFingerprint(loaded.snapshot);
 			if (fingerprint) markQueuedDriverPromptInFlight(rootKey, fingerprint);
 		}
-		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot)) return;
+		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot, ctx)) return;
 		const additions = isWorkflowDone(loaded.snapshot)
 			? [buildDoneWorkflowBoundaryReminder(loaded.snapshot)]
 			: [composeSystemReminder(loaded.snapshot, loaded.sliceHistory, loaded.stopHistory)];

package/extensions/completion/prompt-surfaces.ts

@@ -201,6 +201,7 @@ export function buildContextProposalAnalystPrompt(projectName: string, discussio
 		"Infer the current implementation mission from the discussion.",
 		"Prefer the latest clear user implementation intent over older background context.",
 		"Treat stale, completed, or explicitly negated topics as context to ignore unless the latest discussion clearly reopens them.",
+		"If canonical workflow context includes a /cook hint, use it as a high-priority cue for how to interpret the recent discussion without treating it as an unconditional override.",
 	];
 	if (contextLines.length > 0) lines.push("", "Canonical workflow context:", ...contextLines);
 	lines.push("", "Recent discussion:", discussion || "(none)");

package/extensions/completion/proposal.ts

@@ -342,6 +342,11 @@ export function serializeRecentDiscussionEntries(entries: RecentDiscussionEntry[
 		.join("\n\n");
 }
 
+function contextHintEntry(hintText: string | undefined): RecentDiscussionEntry[] {
+	const normalized = normalizeProposalLine(hintText ?? "");
+	return normalized ? [{ role: "user", text: `Hint: ${normalized}` }] : [];
+}
+
 const RECENT_DISCUSSION_IMPLEMENTATION_INTENT_REGEX =
 	/(?:\b(?:fix|update|add|remove|restore|refactor|ship|support|wire|route|rewrite|replace|preserve|filter|separate|refresh|reroute|suppress|align|convert|reconcile|repair|correct|implement|build|land|block|allow|keep|edit|document|write)\b|(?:修正|修復|修复|更新|新增|移除|恢復|恢复|重構|重构|調整|调整|過濾|过滤|分離|分离|刷新|替換|替换|抑制|對齊|对齐|實作|实现|落地|修補|修补|阻止|允許|允许|轉換|转换|保留|保持))/iu;
 
@@ -716,13 +721,63 @@ function missionTextOverlapsTopic(mission: string, topic: string): boolean {
 	return overlap.length >= Math.min(2, Math.min(missionTokens.length, topicTokens.length));
 }
 
-function proposalOverlapsTopic(proposal: ContextProposal, topic: string): boolean {
+function proposalOverlapsTopic(proposal: ContextProposal | ContextProposalAlternate, topic: string): boolean {
 	if (!topic.trim()) return false;
 	if (missionTextOverlapsTopic(proposal.mission, topic)) return true;
 	const bodyTexts = [proposal.basisPreview, ...proposal.scope, ...proposal.constraints, ...proposal.acceptance].filter(Boolean);
 	return bodyTexts.some((text) => missionTextOverlapsTopic(text, topic) || missionTextOverlapsTopic(topic, text));
 }
 
+function hintOverlapScore(text: string, hintText: string): number {
+	const normalizedText = normalizeMissionAnchorText(text).toLowerCase();
+	const normalizedHint = normalizeMissionAnchorText(hintText).toLowerCase();
+	if (!normalizedText || !normalizedHint) return 0;
+	if (normalizedText === normalizedHint) return 10;
+	if (normalizedText.includes(normalizedHint) || normalizedHint.includes(normalizedText)) return 6;
+	const textTokens = missionAnchorSemanticTokens(normalizedText);
+	const hintTokens = missionAnchorSemanticTokens(normalizedHint);
+	if (textTokens.length === 0 || hintTokens.length === 0) return 0;
+	const hintSet = new Set(hintTokens);
+	const overlap = textTokens.filter((token) => hintSet.has(token));
+	if (overlap.length === 0) return 0;
+	return overlap.length / Math.max(textTokens.length, hintTokens.length);
+}
+
+function proposalHintScore(proposal: ContextProposal | ContextProposalAlternate, hintText: string): number {
+	return (
+		hintOverlapScore(proposal.mission, hintText) * 4 +
+		proposal.scope.reduce((sum, item) => sum + hintOverlapScore(item, hintText) * 2, 0) +
+		proposal.constraints.reduce((sum, item) => sum + hintOverlapScore(item, hintText), 0) +
+		proposal.acceptance.reduce((sum, item) => sum + hintOverlapScore(item, hintText), 0)
+	);
+}
+
+function selectHintPreferredProposal(proposal: ContextProposal | undefined, hintText: string | undefined): ContextProposal | undefined {
+	if (!proposal || !hintText) return proposal;
+	const candidates = [proposal, ...(proposal.alternateProposals ?? [])].filter((candidate, index, list) =>
+		list.findIndex((other) => missionAnchorsStrictlyEquivalent(other.mission, candidate.mission)) === index,
+	);
+	if (candidates.length <= 1) return proposal;
+	const scored = candidates.map((candidate, index) => ({ candidate, index, score: proposalHintScore(candidate, hintText) }));
+	const best = scored.reduce((current, item) => (item.score > current.score ? item : current), scored[0]);
+	if (best.score <= 0 || best.index === 0) return proposal;
+	const selected = best.candidate;
+	const alternates = candidates
+		.filter((_, index) => index !== best.index)
+		.map((candidate) => ({ ...candidate, analysis: finalizeContextProposalAnalysis(candidate.analysis, [candidate.goalText, candidate.mission]) }));
+	return {
+		...selected,
+		alternateProposals: alternates,
+		analysis: finalizeContextProposalAnalysis(
+			{
+				...selected.analysis,
+				alternateMissions: alternates.map((candidate) => candidate.mission),
+			},
+			[selected.goalText, selected.mission, hintText, ...alternates.map((candidate) => candidate.mission)],
+		),
+	};
+}
+
 function extractSuppressedNegatedTopics(proposal: ContextProposal): string[] {
 	return uniqueProposalItems(
 		proposal.constraints.filter((item) => looksLikeConstraint(item) && CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX.test(normalizeProposalLine(item))),
@@ -1186,20 +1241,25 @@ export async function deriveCookContextProposalFromRecentDiscussion(
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
 	deps: ProposalParseDeps & {
-		analyzeContextProposal?: (recentEntries: RecentDiscussionEntry[]) => Promise<ContextProposal | undefined>;
+		analyzeContextProposal?: (recentEntries: RecentDiscussionEntry[], hintText?: string) => Promise<ContextProposal | undefined>;
 		workflowContext?: ContextProposalWorkflowContext;
+		hintText?: string;
 	},
 ): Promise<ContextProposal | undefined> {
-	if (recentEntries.length === 0) return undefined;
-	for (const candidateEntries of recentDiscussionWindows(recentEntries, deps.stripCodeBlocks)) {
-		const analyzed = applyWorkflowContextToProposal(await deps.analyzeContextProposal?.(candidateEntries), deps.workflowContext, deps);
+	const effectiveEntries = [...contextHintEntry(deps.hintText), ...recentEntries];
+	if (effectiveEntries.length === 0) return undefined;
+	for (const candidateEntries of recentDiscussionWindows(effectiveEntries, deps.stripCodeBlocks)) {
+		const analyzed = selectHintPreferredProposal(
+			applyWorkflowContextToProposal(await deps.analyzeContextProposal?.(candidateEntries, deps.hintText), deps.workflowContext, deps) ?? undefined,
+			deps.hintText,
+		);
 		if (analyzed) return analyzed;
 		const structured = applyWorkflowContextToProposal(
 			extractContextProposalFromStructuredSession(candidateEntries, projectName, deps),
 			deps.workflowContext,
 			deps,
 		);
-		if (structured) return structured;
+		if (structured) return selectHintPreferredProposal(structured, deps.hintText);
 	}
 	return undefined;
 }

package/extensions/completion/role-runner.ts

@@ -79,6 +79,7 @@ const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
 	"You may additionally include optional keys alternate_missions, completed_topics, and negated_topics when they are clearly supported by the discussion and canonical workflow context.",
 	"mission must be a concise implementation mission anchor sentence.",
 	"Prefer the latest clear user implementation intent over older background context when they differ.",
+	"If canonical workflow context includes a /cook hint, treat it as a high-priority disambiguation signal, but do not let it bypass clear contradictory repo truth or approval-only confirmation.",
 	"Do not reopen work that the canonical workflow context says is done, completed, historical, or already covered unless the latest discussion clearly asks to revisit it.",
 	"Treat stale, weakly related, or explicitly negated topics as noise instead of mission scope.",
 	"scope must contain only work items that directly support the mission.",

package/package.json

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

package/scripts/context-proposal-test.sh

@@ -1101,8 +1101,8 @@ assert plan['plan_basis'] == 'user_refocus', 'plan_basis should reset to user_re
 assert active['status'] == 'idle', 'active-slice should reset to idle for the next workflow round'
 PY
 
-# Active workflow: /cook <text> should be rejected before routing or proposal confirmation
-# and still leave canonical state unchanged.
+# Active workflow: /cook <hint> should bias active-workflow proposal derivation,
+# still route through the chooser, and leave canonical state unchanged when the user cancels.
 ACTIVE_INLINE_REJECTION_ROUTING="$TMPDIR/context-proposal-active-inline-arg-routing.json"
 ACTIVE_INLINE_REJECTION_PROPOSAL="$TMPDIR/context-proposal-active-inline-arg-proposal.json"
 ACTIVE_INLINE_REJECTION_CHOOSER="$TMPDIR/context-proposal-active-inline-arg-chooser.json"
@@ -1138,9 +1138,9 @@ import sys
 from pathlib import Path
 
 output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
-routing = Path(sys.argv[3])
+routing = json.loads(Path(sys.argv[3]).read_text())
 proposal = Path(sys.argv[4])
-chooser = Path(sys.argv[5])
+chooser = json.loads(Path(sys.argv[5]).read_text())
 before = json.loads(Path(sys.argv[6]).read_text())
 tracked = [
     Path('.agent/mission.md'),
@@ -1151,16 +1151,17 @@ tracked = [
     Path('.agent/verification-evidence.json'),
 ]
 
-assert '/cook only supports the bare /cook entrypoint.' in output, 'active /cook <text> rejection should explain the bare-only contract'
-assert not routing.exists(), 'active /cook <text> rejection should not run active-workflow routing'
-assert not proposal.exists(), 'active /cook <text> rejection should not open proposal confirmation'
-assert not chooser.exists(), 'active /cook <text> rejection should not open the existing-workflow chooser'
+assert routing['action'] == 'refocus', 'active /cook <hint> should run active-workflow routing'
+assert routing['proposedMissionAnchor'] == 'Replacement mission for the active workflow.', 'active /cook <hint> should bias toward the hinted replacement mission'
+assert json.loads(proposal.read_text())['mission'] == 'Replacement mission for the active workflow.', 'active /cook <hint> should carry the hinted mission into the final replacement proposal'
+assert chooser['choices'][1].startswith('Start new workflow from recent discussion'), 'active /cook <hint> should open the existing-workflow chooser'
+assert 'Cancelled replacement workflow proposal.' in output or 'Cancelled existing workflow confirmation.' in output, 'active /cook <hint> cancel should report cancellation'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'active /cook <text> rejection should leave canonical files unchanged'
+assert before == after, 'active /cook <hint> cancel should leave canonical files unchanged'
 PY
 
-# Completed workflow: /cook <text> should be rejected before any next-round proposal is derived
-# and still leave canonical state unchanged.
+# Completed workflow: /cook <hint> should bias next-round proposal derivation and still leave canonical state
+# unchanged when the user cancels the approval-only proposal.
 mark_done
 
 DONE_INLINE_REJECTION_ROUTING="$TMPDIR/context-proposal-done-inline-arg-routing.json"
@@ -1198,7 +1199,7 @@ from pathlib import Path
 
 output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 routing = Path(sys.argv[3])
-proposal = Path(sys.argv[4])
+proposal = json.loads(Path(sys.argv[4]).read_text())
 chooser = Path(sys.argv[5])
 before = json.loads(Path(sys.argv[6]).read_text())
 tracked = [
@@ -1210,14 +1211,14 @@ tracked = [
     Path('.agent/verification-evidence.json'),
 ]
 state_before = json.loads(before['state.json'])
-assert state_before['current_phase'] == 'done', 'done /cook <text> rejection should start from a completed workflow'
-assert state_before['project_done'] is True, 'done /cook <text> rejection should start from project_done=true'
-assert '/cook only supports the bare /cook entrypoint.' in output, 'done /cook <text> rejection should explain the bare-only contract'
-assert not routing.exists(), 'done /cook <text> rejection should not run active/done workflow routing'
-assert not proposal.exists(), 'done /cook <text> rejection should not open next-round proposal confirmation'
-assert not chooser.exists(), 'done /cook <text> rejection should not open the chooser flow'
+assert state_before['current_phase'] == 'done', 'done /cook <hint> should start from a completed workflow'
+assert state_before['project_done'] is True, 'done /cook <hint> should start from project_done=true'
+assert not routing.exists(), 'done /cook <hint> should not run active-workflow routing while starting the next round'
+assert proposal['mission'] == 'Update README guidance for the next workflow round.', 'done /cook <hint> should bias next-round mission derivation toward the hint'
+assert not chooser.exists(), 'done /cook <hint> should not open the existing-workflow chooser when starting the next round'
+assert 'Cancelled next workflow round proposal.' in output, 'done /cook <hint> cancel should report next-round proposal cancellation'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'done /cook <text> rejection should leave canonical files unchanged'
+assert before == after, 'done /cook <hint> cancel should leave canonical files unchanged'
 PY
 
 # Completed workflow again: /cook with no goal should be able to use model-assisted

package/scripts/refocus-test.sh

@@ -117,9 +117,9 @@ import sys
 from pathlib import Path
 
 output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
-routing = Path(sys.argv[3])
+routing = json.loads(Path(sys.argv[3]).read_text())
 proposal = Path(sys.argv[4])
-chooser = Path(sys.argv[5])
+chooser = json.loads(Path(sys.argv[5]).read_text())
 initial_mission = sys.argv[6]
 before = json.loads(Path(sys.argv[7]).read_text())
 tracked = [
@@ -131,13 +131,14 @@ tracked = [
     Path('.agent/verification-evidence.json'),
 ]
 current_state = json.loads(before['state.json'])
-assert current_state['mission_anchor'] == initial_mission, 'active /cook <text> rejection should start from the current mission anchor'
-assert '/cook only supports the bare /cook entrypoint.' in output, 'active /cook <text> rejection should explain the bare-only contract'
-assert not routing.exists(), 'active /cook <text> rejection should not run active-workflow routing'
-assert not proposal.exists(), 'active /cook <text> rejection should not open final proposal confirmation'
-assert not chooser.exists(), 'active /cook <text> rejection should not open the existing-workflow chooser'
+assert current_state['mission_anchor'] == initial_mission, 'active /cook <hint> should start from the current mission anchor'
+assert routing['action'] == 'refocus', 'active /cook <hint> should route through active-workflow replacement assessment'
+assert routing['proposedMissionAnchor'] == 'Replacement mission that should stay in the main chat.', 'active /cook <hint> should preserve the hinted replacement mission'
+assert not proposal.exists(), 'active /cook <hint> chooser cancel should not open final proposal confirmation'
+assert chooser['choices'][1].startswith('Start new workflow from recent discussion'), 'active /cook <hint> should open the existing-workflow chooser'
+assert 'Cancelled existing workflow confirmation.' in output, 'active /cook <hint> chooser cancel should report cancellation'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'active /cook <text> rejection should leave canonical files unchanged'
+assert before == after, 'active /cook <hint> chooser cancel should leave canonical files unchanged'
 PY
 
 SESSION_INITIAL_REFOCUS="$TMPDIR/session-initial-bare-refocus.jsonl"

package/scripts/release-check.sh

@@ -14,9 +14,9 @@ from pathlib import Path
 
 checks = {
     "README.md": [
-        "Bare `/cook` is the only supported workflow entrypoint.",
-        "`/cook <text>` is no longer supported; put mission text in the main chat, then rerun bare `/cook`.",
-        "clarify the mission in the main chat before rerunning bare `/cook`",
+        "`/cook` supports both bare discussion-driven startup and optional inline intent hints.",
+        "`/cook <hint>` acts as a high-priority intent hint that helps proposal derivation interpret the recent discussion",
+        "clarify the mission in the main chat before rerunning `/cook`",
         "Matching or unclear discussion resumes from canonical `.agent/**` state.",
         "approval-only Start/Cancel gate",
         "Start new workflow from recent discussion",
@@ -24,26 +24,25 @@ checks = {
         "README/CHANGELOG updates still count as concrete repo changes",
         "assistant-produced summaries and plan/spec/design-doc/proposal-only artifacts do not",
         "Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow.",
-        "`/cook <text>` is rejected without running proposal routing or rewriting workflow state.",
+        "Optional `/cook <hint>` text biases that routing and candidate ranking toward the hinted implementation intent",
     ],
     "CHANGELOG.md": [
+        "restored optional `/cook <hint>` support as a soft intent hint that biases context analysis, proposal ranking, active-workflow disambiguation, and next-round startup without bypassing fail-closed routing or the approval-only Start/Cancel gate",
         "removed inline `/cook <text>` argument support so bare `/cook` is now the only supported workflow entrypoint",
-        "packaged release parity fail closed when command arguments are passed instead of discussion driving proposal derivation",
         "historically allowed `/cook <hint>` as an analyst-only high-priority prompt",
-        "that inline-argument path has since been removed so bare `/cook` is now the only supported entrypoint",
     ],
     "extensions/completion/index.ts": [
-        'description: "Bare /cook workflow: start, continue, refocus, or start the next round"',
+        'description: "/cook workflow: start, continue, refocus, or start the next round (optional hint supported)"',
         'const COOK_BARE_ONLY_GUIDANCE =',
-        '"/cook only supports the bare /cook entrypoint. Move mission text into the main chat, then rerun /cook."',
+        '"/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 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."',
     ],
 }
 
 forbidden = {
-    "README.md": ["compatibility" + " shim", "/cook <hint>", "optional inline /cook hint"],
+    "README.md": ["compatibility" + " shim", "optional inline /cook hint"],
     "CHANGELOG.md": ["compatibility" + " shim"],
-    "extensions/completion/index.ts": ["temporary" + " compatibility" + " shim, pass /cook", "inline /cook hint", "optional inline /cook hint"],
+    "extensions/completion/index.ts": ["temporary" + " compatibility" + " shim, pass /cook", "optional inline /cook hint"],
 }
 
 for path, needles in checks.items():

package/scripts/smoke-test.sh

@@ -76,19 +76,20 @@ pi -e "$PKG_ROOT" -p "/cook smoke-test mission" \
   >"$TMPDIR/pi-completion-smoke-inline-arg.out" 2>"$TMPDIR/pi-completion-smoke-inline-arg.err"
 
 python3 - "$TMPDIR/pi-completion-smoke-inline-arg.out" "$TMPDIR/pi-completion-smoke-inline-arg.err" "$INLINE_REJECTION_ROUTING_SNAPSHOT" "$INLINE_REJECTION_PROPOSAL_SNAPSHOT" "$INLINE_REJECTION_CHOOSER_SNAPSHOT" <<'PY'
+import json
 import sys
 from pathlib import Path
 
 output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 routing = Path(sys.argv[3])
-proposal = Path(sys.argv[4])
+proposal = json.loads(Path(sys.argv[4]).read_text())
 chooser = Path(sys.argv[5])
 
-assert not Path('.agent').exists(), 'startup /cook <text> rejection should leave canonical state untouched'
-assert not routing.exists(), 'startup /cook <text> rejection should not open active-workflow routing'
-assert not proposal.exists(), 'startup /cook <text> rejection should not prepare a proposal snapshot'
-assert not chooser.exists(), 'startup /cook <text> rejection should not open the chooser flow'
-assert '/cook only supports the bare /cook entrypoint.' in output, 'startup /cook <text> rejection should explain the bare-only contract'
+assert not Path('.agent').exists(), 'startup /cook <hint> cancel should leave canonical state untouched'
+assert not routing.exists(), 'startup /cook <hint> should not open active-workflow routing before a workflow exists'
+assert proposal['mission'] == 'Smoke-test inline hint startup mission.', 'startup /cook <hint> should bias proposal derivation toward the hinted mission'
+assert not chooser.exists(), 'startup /cook <hint> should not open the existing-workflow chooser before a workflow exists'
+assert 'Cancelled recent-discussion workflow proposal.' in output, 'startup /cook <hint> cancel should report proposal cancellation'
 PY
 
 write_session "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_DISCUSSION"