@linimin/pi-letscook 0.1.41 → 0.1.43

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.1.43
+
+### Fixed
+
+- stopped injecting completion-workflow reminder and compaction-resume context into ordinary primary-agent turns after canonical `continuation_policy` reaches `done`, so users must rerun `/cook` before the workflow protocol reactivates
+
+## 0.1.42
+
+### Changed
+
+- allowed `/cook <hint>` as an analyst-only high-priority prompt that focuses proposal derivation without bypassing the existing approval-only Start/Cancel confirmation gate or canonical fail-closed routing
+
 ## 0.1.41
 
 ### Changed

package/README.md

@@ -32,32 +32,33 @@ Then run `/reload` in Pi.
 
 ## Quick start
 
-Primary entrypoint:
+Primary entrypoints:
 
 ```text
 /cook
+/cook <hint>
 ```
 
-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. If the recent context is fuzzy, `/cook <hint>` can provide a short high-priority user hint for the proposal analyst while still relying on recent discussion to fill in scope, constraints, and acceptance. 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`
 
-Bare `/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` 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. An inline `/cook <hint>` only guides proposal derivation; it does not bypass confirmation or become canonical state on its own.
 
-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, bare `/cook` fails closed, leaves canonical `.agent/**` state unchanged, and tells you to clarify the mission in the main chat before rerunning bare `/cook`.
+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 an inline hint conflicts with the recent discussion, `/cook` also fails closed instead of guessing.
 
 ## How `/cook` works
 
-Bare `/cook` is the only supported workflow entrypoint.
+Bare `/cook` and `/cook <hint>` are the supported workflow entrypoints.
 
-| Repo state | Bare `/cook` |
+| Repo state | `/cook` behavior |
 |---|---|
-| No workflow yet | Summarizes recent main-chat discussion into a startup proposal, then asks for approval with **Start** or **Cancel**. If the discussion is weak, ambiguous, assistant-produced, or only a plan/spec/design-doc/proposal artifact instead of concrete repo changes, `/cook` fails closed without writing `.agent/**` state and tells you to clarify the mission in the main chat before rerunning bare `/cook`. |
-| Active workflow exists | Reads the current mission plus recent non-command main-chat discussion. Matching or unclear discussion resumes from canonical `.agent/**` state. Clear replacement discussion about different concrete repo changes opens a chooser first, then only rewrites canonical state after the follow-on **Start** confirmation. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. |
-| 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`. |
+| No workflow yet | Summarizes recent main-chat discussion, optionally focused by `/cook <hint>`, into a startup proposal, then asks for approval with **Start** or **Cancel**. If the discussion is weak, ambiguous, assistant-produced, or only a plan/spec/design-doc/proposal artifact instead of concrete repo changes, `/cook` fails closed without writing `.agent/**` state and tells you to clarify the mission in the main chat before rerunning `/cook`. |
+| Active workflow exists | Reads the current mission plus recent non-command main-chat discussion, with any inline hint treated as extra proposal-analysis guidance only. Matching or unclear discussion resumes from canonical `.agent/**` state. Clear replacement discussion about different concrete repo changes opens a chooser first, then only rewrites canonical state after the follow-on **Start** confirmation. Assistant/summary artifacts or plan/spec/design-doc/proposal-only context do not refocus the workflow. |
+| Previous workflow is `done` | Starts the next round from recent main-chat discussion, optionally focused by `/cook <hint>`, 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 `/cook`. |
 
 ## Approval-only confirmation and fail-closed behavior
 
@@ -67,7 +68,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 bare `/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 bare `/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.
+When `/cook` cannot derive a clear startup, next-round, or replacement proposal for concrete repo changes from recent main-chat discussion plus any optional inline hint, 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.
 
 When an active workflow already exists and recent discussion clearly suggests a different workflow, `/cook` shows a separate chooser first:
 

package/extensions/completion/index.ts

@@ -539,10 +539,8 @@ function maybeWriteTestSnapshot(targetPath: string | undefined, content: string)
 }
 
 const COOK_MAIN_CHAT_RERUN_GUIDANCE = "Discuss changes in the main chat and rerun /cook.";
-const COOK_INLINE_ARG_REJECTION_MESSAGE =
-	"Inline /cook arguments are no longer supported. Clarify the mission in the main chat and rerun bare /cook.";
 const COOK_STRUCTURED_DISCUSSION_FAILURE_DETAIL =
-	"Bare /cook failed closed because recent discussion did not contain a clear execution-ready Mission/Scope/Constraints/Acceptance proposal for concrete repo changes. Clarify the concrete repo changes in the main chat and rerun bare /cook.";
+	"/cook failed closed because recent discussion and any optional inline /cook hint 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.";
 
 function buildCookCancellationMessage(prefix: string): string {
 	return `${prefix}. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
@@ -564,6 +562,10 @@ function isWorkflowDone(snapshot: CompletionStateSnapshot | undefined): boolean
 	return asString(snapshot?.state?.continuation_policy) === "done";
 }
 
+function shouldInjectCompletionWorkflowContext(snapshot: CompletionStateSnapshot | undefined): boolean {
+	return Boolean(snapshot) && !isWorkflowDone(snapshot);
+}
+
 function extractTextFromMessageContent(content: unknown): string {
 	if (typeof content === "string") return content.trim();
 	if (!Array.isArray(content)) return "";
@@ -1114,9 +1116,18 @@ function contextProposalAnalystModelArg(model: unknown): string | undefined {
 	return provider && id ? `${provider}/${id}` : undefined;
 }
 
-function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[]): string {
+function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[], hintText?: string): string {
 	const discussion = serializeRecentDiscussionEntries(recentEntries);
-	return [`Project: ${projectName}`, "Infer the current mission from the discussion.", "", "Recent discussion:", discussion].join("\n");
+	const lines = [
+		`Project: ${projectName}`,
+		"Infer the current mission from the discussion.",
+		"If an inline /cook hint is present, treat it as a high-priority user hint that may focus the mission, but do not ignore conflicting discussion or skip missing details.",
+	];
+	if (hintText) {
+		lines.push("", "Inline /cook hint:", hintText);
+	}
+	lines.push("", "Recent discussion:", discussion || "(none)");
+	return lines.join("\n");
 }
 
 function contextProposalAnalystProgressLines(activity: LiveRoleActivity): string[] {
@@ -1145,20 +1156,23 @@ async function runContextProposalAnalystSubprocess(
 	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any },
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
+	hintText?: string,
 ): Promise<string | undefined> {
 	const modelArg = contextProposalAnalystModelArg(ctx.model);
 	if (!modelArg) return undefined;
 	const cwd = getCtxCwd(ctx);
 	const runCwd = findCompletionRoot(cwd) ?? findRepoRoot(cwd) ?? cwd;
 	const rootKey = completionRootKey(undefined, cwd);
-	const prompt = buildContextProposalAnalystPrompt(projectName, recentEntries);
+	const prompt = buildContextProposalAnalystPrompt(projectName, recentEntries, hintText);
 	const systemPromptTemp = await writeTempFile("pi-cook-proposal-analyst-", CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT);
 	const analystRole = "cook-proposal-analyst";
 	const args: string[] = ["--mode", "json", "-p", "--no-session", "--append-system-prompt", systemPromptTemp.filePath, "--model", modelArg, prompt];
 	const invocation = getPiInvocation(args);
 	const liveActivity = createLiveRoleActivity(analystRole);
-	liveActivity.progress = "Analyzing recent discussion";
-	liveActivity.currentAction = "Reading recent discussion and preparing a startup proposal";
+	liveActivity.progress = hintText ? "Analyzing recent discussion and inline hint" : "Analyzing recent discussion";
+	liveActivity.currentAction = hintText
+		? "Reading recent discussion plus the inline /cook hint and preparing a startup proposal"
+		: "Reading recent discussion and preparing a startup proposal";
 	liveActivity.assistantSummary = liveActivity.progress;
 	liveActivity.recentActivity = pushRecentActivity(liveActivity.recentActivity, `assistant: ${liveActivity.progress}`);
 	const messages: RoleMessage[] = [];
@@ -1188,6 +1202,17 @@ async function runContextProposalAnalystSubprocess(
 					stdio: ["ignore", "pipe", "pipe"],
 					shell: false,
 				});
+				let settled = false;
+				const resolveOnce = (value: string | undefined) => {
+					if (settled) return;
+					settled = true;
+					resolve(value);
+				};
+				const abort = () => {
+					proc.kill("SIGTERM");
+					resolveOnce(undefined);
+				};
+				const handleSigint = () => abort();
 				let buffer = "";
 				const processLine = (line: string) => {
 					if (!line.trim()) return;
@@ -1208,14 +1233,19 @@ async function runContextProposalAnalystSubprocess(
 					stderr += chunk.toString();
 				});
 				proc.on("close", (code) => {
+					process.off("SIGINT", handleSigint);
 					if (buffer.trim()) processLine(buffer);
-					resolve(code === 0 ? liveActivity.lastAssistantText?.trim() || undefined : undefined);
+					resolveOnce(code === 0 ? liveActivity.lastAssistantText?.trim() || undefined : undefined);
+				});
+				proc.on("error", () => {
+					process.off("SIGINT", handleSigint);
+					resolveOnce(undefined);
 				});
-				proc.on("error", () => resolve(undefined));
+				process.once("SIGINT", handleSigint);
 				if (overlay) {
 					overlay.onAbort = () => {
-						proc.kill("SIGTERM");
-						resolve(undefined);
+						process.off("SIGINT", handleSigint);
+						abort();
 					};
 				}
 			});
@@ -1253,15 +1283,16 @@ async function analyzeContextProposalWithAgent(
 	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any; modelRegistry?: any },
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
+	hintText?: string,
 ): Promise<ContextProposal | undefined> {
 	if (shouldDisableContextProposalAnalyst()) return undefined;
 	const testOutput = completionTestContextProposalAnalystOutput();
 	if (testOutput) {
 		return parseContextProposalAnalystOutput(testOutput, projectName);
 	}
-	if (recentEntries.length === 0) return undefined;
+	if (recentEntries.length === 0 && !hintText?.trim()) return undefined;
 	try {
-		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries);
+		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries, hintText);
 		if (!raw) return undefined;
 		return parseContextProposalAnalystOutput(raw, projectName);
 	} catch (error) {
@@ -1719,17 +1750,19 @@ function extractContextProposalFromStructuredSession(
 async function extractContextProposalFromSession(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
+	hintText?: string,
 ): Promise<ContextProposal | undefined> {
 	const recentEntries = collectRecentDiscussionEntries(ctx);
-	return (await analyzeContextProposalWithAgent(ctx, projectName, recentEntries)) ??
+	return (await analyzeContextProposalWithAgent(ctx, projectName, recentEntries, hintText)) ??
 		extractContextProposalFromStructuredSession(recentEntries, projectName);
 }
 
 async function deriveCookContextProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
+	hintText?: string,
 ): Promise<ContextProposal | undefined> {
-	return await extractContextProposalFromSession(ctx, projectName);
+	return await extractContextProposalFromSession(ctx, projectName, hintText);
 }
 
 async function confirmContextProposal(
@@ -2005,10 +2038,11 @@ function buildEvaluationRoleReminderText(snapshot: CompletionStateSnapshot, role
 async function assessActiveWorkflowProposalRouting(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	snapshot: CompletionStateSnapshot,
+	hintText?: string,
 ): Promise<ActiveWorkflowProposalAssessment> {
 	const currentMission = currentMissionAnchor(snapshot);
 	const projectName = path.basename(snapshot.files.root);
-	const proposal = await deriveCookContextProposal(ctx, projectName);
+	const proposal = await deriveCookContextProposal(ctx, projectName, hintText);
 	if (!proposal) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "unclear",
@@ -3703,7 +3737,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			const fingerprint = completionContinuationFingerprint(loaded.snapshot);
 			if (fingerprint) markQueuedDriverPromptInFlight(rootKey, fingerprint);
 		}
-		if (!loaded) return;
+		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot)) return;
 		const markerText = await readText(loaded.snapshot.files.compactionMarkerPath);
 		let marker: JsonRecord | undefined;
 		if (markerText) {
@@ -3726,7 +3760,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 
 	pi.on("session_before_compact", async (event, ctx) => {
 		const loaded = await loadCompletionDataForReminder(getCtxCwd(ctx));
-		if (!loaded) return;
+		if (!loaded || !shouldInjectCompletionWorkflowContext(loaded.snapshot)) return;
 		const { preparation } = event;
 		const summary = buildResumeCapsule(loaded.snapshot, loaded.sliceHistory, loaded.stopHistory);
 		await fsp.mkdir(loaded.snapshot.files.tmpDir, { recursive: true });
@@ -4073,11 +4107,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 	pi.registerCommand("cook", {
 		description: "Discussion-driven /cook workflow: start, continue, refocus, or start the next round",
 		handler: async (args, ctx) => {
-			const inlineArgs = args.trim();
-			if (inlineArgs) {
-				emitCommandText(ctx, COOK_INLINE_ARG_REJECTION_MESSAGE, "info");
-				return;
-			}
+			const inlineHint = args.trim() || undefined;
 			let goal: string | undefined;
 			const cwd = getCtxCwd(ctx);
 			let snapshot = await loadCompletionSnapshot(cwd);
@@ -4089,7 +4119,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!snapshot) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
-				const proposal = await deriveCookContextProposal(ctx, projectName);
+				const proposal = await deriveCookContextProposal(ctx, projectName, inlineHint);
 				if (!proposal) {
 					emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(), "info");
 					return;
@@ -4127,7 +4157,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!goal) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
-					const proposal = await deriveCookContextProposal(ctx, projectName);
+					const proposal = await deriveCookContextProposal(ctx, projectName, inlineHint);
 					if (!proposal) {
 						emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage("The previous completion workflow is already done."), "info");
 						return;
@@ -4146,7 +4176,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
 					emitCommandText(ctx, `Started a new completion workflow round from recent discussion: ${decision.missionAnchor}`, "info");
 				} else {
-					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot);
+					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, inlineHint);
 					if (assessment.action !== "refocus" || !assessment.proposal) {
 						await resumeActiveWorkflowFromCanonicalState(pi, ctx, snapshot);
 						return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "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/canonical-evidence-artifact-test.sh

@@ -392,4 +392,48 @@ assert 'Verification evidence summary:' in text, text
 assert 'selected_slice' in text, text
 PY
 
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+state_path = Path('.agent/state.json')
+plan_path = Path('.agent/plan.json')
+active_path = Path('.agent/active-slice.json')
+
+state = json.loads(state_path.read_text())
+state.update({
+    'current_phase': 'done',
+    'continuation_policy': 'done',
+    'continuation_reason': 'Fixture is complete; ordinary primary-agent turns should stay outside completion until /cook runs again.',
+    'project_done': True,
+    'remaining_high_value_gaps': 0,
+    'unsatisfied_contract_ids': [],
+    'next_mandatory_action': None,
+    'next_mandatory_role': None,
+    'remaining_stop_judges': 0,
+    'contract_status': 'done',
+})
+state_path.write_text(json.dumps(state, indent=2) + '\n')
+
+plan = json.loads(plan_path.read_text())
+for slice_data in plan.get('candidate_slices', []):
+    if slice_data.get('slice_id') == 'evidence-fixture':
+        slice_data['status'] = 'done'
+plan_path.write_text(json.dumps(plan, indent=2) + '\n')
+
+active = json.loads(active_path.read_text())
+active['status'] = 'done'
+active_path.write_text(json.dumps(active, indent=2) + '\n')
+PY
+
+rm -f "$SYSTEM_REMINDER"
+PI_COMPLETION_TEST_SYSTEM_REMINDER_PATH="$SYSTEM_REMINDER" \
+pi -e "$PKG_ROOT" -p "Summarize the latest release briefly." \
+  >"$TMPDIR/pi-canonical-evidence-done-reminder.out" 2>"$TMPDIR/pi-canonical-evidence-done-reminder.err"
+
+[[ ! -f "$SYSTEM_REMINDER" ]] || {
+  echo "expected no completion reminder snapshot when continuation_policy is done" >&2
+  exit 1
+}
+
 echo "canonical evidence artifact test passed: $TMPDIR"

package/scripts/context-proposal-test.sh

@@ -178,7 +178,7 @@ output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 snapshot = Path(sys.argv[3])
 assert not Path('.agent').exists(), 'missing-section structured discussion should fail closed without writing canonical state'
 assert not snapshot.exists(), 'missing-section structured discussion should not emit a proposal snapshot when bare /cook fails closed'
-assert 'Bare /cook failed closed' in output, 'missing-section structured discussion should explain the fail-closed startup outcome'
+assert '/cook failed closed' in output, 'missing-section structured discussion should explain the fail-closed startup outcome'
 assert 'Mission/Scope/Constraints/Acceptance' in output, 'missing-section structured discussion should explain the strict fallback requirement'
 PY
 
@@ -198,7 +198,7 @@ from pathlib import Path
 
 output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 assert not Path('.agent').exists(), 'ambiguous structured discussion should fail closed without writing canonical state'
-assert 'Bare /cook failed closed' in output, 'ambiguous structured discussion should explain the fail-closed startup outcome'
+assert '/cook failed closed' in output, 'ambiguous structured discussion should explain the fail-closed startup outcome'
 assert 'Mission/Scope/Constraints/Acceptance' in output, 'ambiguous structured discussion should explain the strict fallback requirement'
 PY
 
@@ -289,7 +289,7 @@ output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 snapshot = Path(sys.argv[3])
 assert not Path('.agent').exists(), 'planning-only startup should fail closed without writing canonical state'
 assert not snapshot.exists(), 'planning-only startup should not emit a proposal snapshot when bare /cook fails closed'
-assert 'Bare /cook failed closed' in output, 'planning-only startup should explain the fail-closed startup outcome'
+assert '/cook failed closed' in output, 'planning-only startup should explain the fail-closed startup outcome'
 assert 'Mission/Scope/Constraints/Acceptance' in output, 'planning-only startup should still explain the structured discussion requirement'
 assert 'concrete repo changes' in output, 'planning-only startup should explain that bare /cook now expects execution-ready repo changes'
 PY
@@ -495,7 +495,7 @@ output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 snapshot = Path(sys.argv[3])
 assert not Path('.agent').exists(), 'assistant-only startup summary should fail closed without writing canonical state'
 assert not snapshot.exists(), 'assistant-only startup summary should not emit a proposal snapshot when bare /cook fails closed'
-assert 'Bare /cook failed closed' in output, 'assistant-only startup summary should explain the fail-closed startup outcome'
+assert '/cook failed closed' in output, 'assistant-only startup summary should explain the fail-closed startup outcome'
 assert 'concrete repo changes' in output, 'assistant-only startup summary should explain that bare /cook expects execution-ready repo changes from main-chat discussion'
 PY
 
@@ -523,7 +523,7 @@ output = Path(sys.argv[1]).read_text() + Path(sys.argv[2]).read_text()
 snapshot = Path(sys.argv[3])
 assert not Path('.agent').exists(), 'analyst-derived ambiguous generic discussion should fail closed without writing canonical state'
 assert not snapshot.exists(), 'analyst-derived ambiguous generic discussion should not emit a proposal snapshot when bare /cook fails closed'
-assert 'Bare /cook failed closed' in output, 'analyst-derived ambiguous generic discussion should explain the fail-closed startup outcome'
+assert '/cook failed closed' in output, 'analyst-derived ambiguous generic discussion should explain the fail-closed startup outcome'
 PY
 
 # No workflow yet: /cook with no goal should infer from recent discussion through analyst output.
@@ -836,8 +836,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: inline /cook args should be rejected before proposal/routing helpers run
-# and should leave canonical state unchanged.
+# Active workflow: inline /cook hint should flow through routing plus final proposal confirmation
+# and still leave canonical state unchanged when the final proposal is cancelled.
 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"
@@ -859,8 +859,8 @@ Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in
 PY
 
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=refocus \
-PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=cancel \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT='{"mission":"Replacement mission for the active workflow.","scope":["Review the replacement through the existing workflow chooser first."],"constraints":["Do not rewrite canonical state before the final Start confirmation."],"acceptance":["Show the final replacement proposal only after the chooser selects refocus."],"task_type":"completion-workflow","evaluation_profile":"completion-rubric-v1","confidence":0.9}' \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$ACTIVE_INLINE_REJECTION_PROPOSAL" \
 PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$ACTIVE_INLINE_REJECTION_ROUTING" \
 PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$ACTIVE_INLINE_REJECTION_CHOOSER" \
@@ -886,16 +886,15 @@ tracked = [
     Path('.agent/verification-evidence.json'),
 ]
 
-assert 'Inline /cook arguments are no longer supported.' in output, 'active inline /cook args should explain the hard rejection'
-assert 'Clarify the mission in the main chat and rerun bare /cook.' in output, 'active inline /cook args should redirect users back to main chat plus bare /cook'
-assert not routing.exists(), 'active inline /cook args should not run active-workflow routing'
-assert not proposal.exists(), 'active inline /cook args should not open proposal confirmation'
-assert not chooser.exists(), 'active inline /cook args should not open the existing-workflow chooser'
+assert routing.exists(), 'active inline /cook hint should run active-workflow routing'
+assert proposal.exists(), 'active inline /cook hint should open final proposal confirmation after refocus is chosen'
+assert chooser.exists(), 'active inline /cook hint should open the existing-workflow chooser'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'active inline /cook args should leave canonical files unchanged'
+assert before == after, 'active inline /cook hint should leave canonical files unchanged when confirmation is cancelled'
 PY
 
-# Completed workflow: inline /cook args should also fail closed without starting the next round.
+# Completed workflow: inline /cook hint should also drive the next-round proposal and leave
+# canonical state unchanged when the proposal is cancelled.
 mark_done
 
 DONE_INLINE_REJECTION_ROUTING="$TMPDIR/context-proposal-done-inline-arg-routing.json"
@@ -918,8 +917,8 @@ tracked = [
 Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in tracked}, indent=2) + '\n')
 PY
 
-PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
-PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=cancel \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT='{"mission":"Update README guidance for the next workflow round.","scope":["Refresh README guidance for /cook hint-driven startup behavior."],"constraints":["Do not rewrite canonical state before Start is accepted."],"acceptance":["Keep the next-round proposal scoped to README updates only."],"task_type":"completion-workflow","evaluation_profile":"completion-rubric-v1","confidence":0.9}' \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$DONE_INLINE_REJECTION_PROPOSAL" \
 PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$DONE_INLINE_REJECTION_ROUTING" \
 PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$DONE_INLINE_REJECTION_CHOOSER" \
@@ -947,13 +946,11 @@ tracked = [
 state_before = json.loads(before['state.json'])
 assert state_before['current_phase'] == 'done', 'done inline /cook rejection should start from a completed workflow'
 assert state_before['project_done'] is True, 'done inline /cook rejection should start from project_done=true'
-assert 'Inline /cook arguments are no longer supported.' in output, 'done inline /cook args should explain the hard rejection'
-assert 'Clarify the mission in the main chat and rerun bare /cook.' in output, 'done inline /cook args should redirect users back to main chat plus bare /cook'
 assert not routing.exists(), 'done inline /cook args should not run active/done workflow routing'
-assert not proposal.exists(), 'done inline /cook args should not open next-round proposal confirmation'
+assert proposal.exists(), 'done inline /cook hint should open next-round proposal confirmation'
 assert not chooser.exists(), 'done inline /cook args should not open the chooser flow'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'done inline /cook args should leave canonical files unchanged'
+assert before == after, 'done inline /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

@@ -103,6 +103,7 @@ Path(sys.argv[1]).write_text(json.dumps({path.name: path.read_text() for path in
 PY
 
 PI_COMPLETION_EXISTING_WORKFLOW_ACTION=cancel \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT='{"mission":"Replacement mission that should stay in the main chat.","scope":["Replace the current workflow only after explicit approval."],"constraints":["Do not rewrite canonical state before the final Start confirmation."],"acceptance":["Surface the chooser before any replacement workflow rewrite."],"task_type":"completion-workflow","evaluation_profile":"completion-rubric-v1","confidence":0.9}' \
 PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$INLINE_REJECTION_ROUTING" \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$INLINE_REJECTION_PROPOSAL" \
 PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH="$INLINE_REJECTION_CHOOSER" \
@@ -131,13 +132,12 @@ tracked = [
 ]
 current_state = json.loads(before['state.json'])
 assert current_state['mission_anchor'] == initial_mission, 'active inline /cook args should start from the current mission anchor'
-assert 'Inline /cook arguments are no longer supported.' in output, 'active inline /cook args should explain the hard rejection'
-assert 'Clarify the mission in the main chat and rerun bare /cook.' in output, 'active inline /cook args should redirect users back to main chat plus bare /cook'
-assert not routing.exists(), 'active inline /cook args should not run active-workflow routing'
-assert not proposal.exists(), 'active inline /cook args should not open proposal confirmation'
-assert not chooser.exists(), 'active inline /cook args should not open the existing-workflow chooser'
+assert 'Cancelled existing workflow confirmation.' in output, 'active inline /cook hint cancel should surface chooser cancellation'
+assert routing.exists(), 'active inline /cook hint should run active-workflow routing'
+assert not proposal.exists(), 'active inline /cook hint cancel at chooser should not open final proposal confirmation'
+assert chooser.exists(), 'active inline /cook hint should open the existing-workflow chooser'
 after = {path.name: path.read_text() for path in tracked}
-assert before == after, 'active inline /cook args should leave canonical files unchanged'
+assert before == after, 'active inline /cook hint cancel should leave canonical files unchanged'
 PY
 
 SESSION_INITIAL_REFOCUS="$TMPDIR/session-initial-bare-refocus.jsonl"

package/scripts/release-check.sh

@@ -7,15 +7,16 @@ cd "$ROOT"
 echo "[release-check] running control-plane validation, bare /cook parity, startup/refocus/context regressions, canonical evidence artifact, active-slice contract, observability, evaluator calibration, and rubric contract coverage"
 bash .agent/verify_completion_control_plane.sh
 
-echo "[release-check] verifying public bare /cook parity"
+echo "[release-check] verifying public /cook parity"
 python3 - <<'PY'
 import re
 from pathlib import Path
 
 checks = {
     "README.md": [
-        "Bare `/cook` is the only supported workflow entrypoint.",
-        "clarify the mission in the main chat before rerunning bare `/cook`",
+        "Bare `/cook` and `/cook <hint>` are the supported workflow entrypoints.",
+        "If the recent context is fuzzy, `/cook <hint>` can provide a short high-priority user hint for the proposal analyst",
+        "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",
@@ -35,8 +36,8 @@ checks = {
     ],
     "extensions/completion/index.ts": [
         'description: "Discussion-driven /cook workflow: start, continue, refocus, or start the next round"',
-        "Inline /cook arguments are no longer supported. Clarify the mission in the main chat and rerun bare /cook.",
-        "Bare /cook failed closed because recent discussion did not contain a clear execution-ready Mission/Scope/Constraints/Acceptance proposal for concrete repo changes. Clarify the concrete repo changes in the main chat and rerun bare /cook.",
+        "If an inline /cook hint is present, treat it as a high-priority user hint that may focus the mission, but do not ignore conflicting discussion or skip missing details.",
+        "/cook failed closed because recent discussion and any optional inline /cook hint 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.",
     ],
 }
 
@@ -46,32 +47,17 @@ forbidden = {
     "extensions/completion/index.ts": ["temporary" + " compatibility" + " shim, pass /cook"],
 }
 
-public_doc_paths = [
-    Path("README.md"),
-    Path("CHANGELOG.md"),
-    Path("PUBLISHING.md"),
-]
-inline_cook_pattern = re.compile(r"/cook\s*<[^>]+>")
-
 for path, needles in checks.items():
     text = Path(path).read_text()
     for needle in needles:
         if needle not in text:
-            raise SystemExit(f"[release-check] missing expected bare /cook parity text in {path}: {needle}")
+            raise SystemExit(f"[release-check] missing expected /cook parity text in {path}: {needle}")
 
 for path, needles in forbidden.items():
     text = Path(path).read_text()
     for needle in needles:
         if needle in text:
             raise SystemExit(f"[release-check] found stale compatibility wording in {path}: {needle}")
-
-for path in public_doc_paths:
-    text = path.read_text()
-    match = inline_cook_pattern.search(text)
-    if match:
-        raise SystemExit(
-            f"[release-check] found unsupported inline /cook syntax in {path}: {match.group(0)}"
-        )
 PY
 
 npm run smoke-test

package/scripts/smoke-test.sh

@@ -57,12 +57,15 @@ INLINE_REJECTION_ROUTING_SNAPSHOT="$TMPDIR/inline-arg-routing.json"
 INLINE_REJECTION_PROPOSAL_SNAPSHOT="$TMPDIR/inline-arg-proposal.json"
 INLINE_REJECTION_CHOOSER_SNAPSHOT="$TMPDIR/inline-arg-chooser.json"
 BOOTSTRAP_SESSION="$TMPDIR/session-smoke-bootstrap.jsonl"
-BOOTSTRAP_DISCUSSION=$'Mission: Exercise smoke-test bootstrap.\nScope:\n- Materialize the canonical completion control-plane files.\n- Keep the smoke test on supported bare /cook behavior.\nConstraints:\n- Do not rely on inline /cook arguments.\nAcceptance:\n- Scaffold canonical files and kickoff prompts for the smoke fixture.'
+BOOTSTRAP_DISCUSSION=$'Mission: Exercise smoke-test bootstrap.\nScope:\n- Materialize the canonical completion control-plane files.\n- Keep the smoke test on supported /cook startup behavior.\nConstraints:\n- Keep startup proposal confirmation approval-only.\nAcceptance:\n- Scaffold canonical files and kickoff prompts for the smoke fixture.'
+INLINE_HINT_ANALYST_OUTPUT='{"mission":"Smoke-test inline hint startup mission.","scope":["Materialize the canonical completion control-plane files."],"constraints":["Keep startup proposal confirmation approval-only."],"acceptance":["Scaffold canonical files and kickoff prompts for the smoke fixture."],"task_type":"completion-workflow","evaluation_profile":"completion-rubric-v1","confidence":0.91}'
 
 mkdir -p "$ROOT"
 cd "$ROOT"
 git init -q
 
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=cancel \
+PI_COMPLETION_CONTEXT_PROPOSAL_ANALYST_OUTPUT="$INLINE_HINT_ANALYST_OUTPUT" \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
 PI_COMPLETION_TEST_ACTIVE_WORKFLOW_ROUTING_PATH="$INLINE_REJECTION_ROUTING_SNAPSHOT" \
 PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH="$INLINE_REJECTION_PROPOSAL_SNAPSHOT" \
@@ -79,12 +82,11 @@ routing = Path(sys.argv[3])
 proposal = Path(sys.argv[4])
 chooser = Path(sys.argv[5])
 
-assert not Path('.agent').exists(), 'startup inline /cook args should fail closed without creating canonical state'
-assert not routing.exists(), 'startup inline /cook args should not open active-workflow routing'
-assert not proposal.exists(), 'startup inline /cook args should not open the proposal confirmation flow'
-assert not chooser.exists(), 'startup inline /cook args should not open the chooser flow'
-assert 'Inline /cook arguments are no longer supported.' in output, 'startup inline /cook args should explain the hard rejection'
-assert 'Clarify the mission in the main chat and rerun bare /cook.' in output, 'startup inline /cook args should redirect users back to main chat plus bare /cook'
+assert not Path('.agent').exists(), 'startup inline /cook hint cancel should leave canonical state untouched'
+assert not routing.exists(), 'startup inline /cook hint should not open active-workflow routing'
+assert proposal.exists(), 'startup inline /cook hint should still prepare a proposal for confirmation'
+assert not chooser.exists(), 'startup inline /cook hint should not open the chooser flow during startup'
+assert 'Cancelled recent-discussion workflow proposal.' in output, 'startup inline /cook hint cancel should surface the proposal cancellation message'
 PY
 
 write_session "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_DISCUSSION"