@linimin/pi-letscook 0.1.51 → 0.1.52

package/extensions/completion/prompt-surfaces.ts

@@ -2,9 +2,16 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
 	CompletionStateSnapshot,
+	CookNaturalLanguageHandoff,
+	CookTriggerAdoptedArtifact,
+	CookTriggerClarificationActionItem,
+	CookTriggerClarificationLayout,
 	CookTriggerClassification,
 	CookTriggerConfirmationActionItem,
 	CookTriggerConfirmationLayout,
+	CookTriggerRecoveryActionItem,
+	CookTriggerRecoveryLayout,
+	CookTriggerWorkflowBias,
 	LiveRoleActivity,
 } from "./types";
 import type {
@@ -211,13 +218,19 @@ export function buildCookTriggerClassifierPrompt(args: {
 }): string {
 	const lines = [
 		`Project: ${args.projectName}`,
-		"Classify whether the current input is a natural-language handoff to the canonical /cook workflow before the primary agent starts implementation work.",
-		"Return JSON only with keys: intent, confidence, reason, evidence, riskFlags, focusHint.",
-		"intent must be exactly one of route_to_cook, normal_prompt, or unclear.",
-		"Use route_to_cook only when the user is handing control from recent discussion into workflow execution or explicitly asking to let /cook take over.",
-		"Use normal_prompt for ordinary questions, explanations, or direct agent requests that should stay in the main chat.",
+		"Classify whether the current input should stay in the main chat or be intercepted by the workflow-aware router into the canonical /cook workflow before the primary agent starts implementation work.",
+		"Assume router mode reviews every non-bypass normal user turn. Do not require short trigger phrases or explicit /cook text before choosing offer_workflow.",
+		"Return JSON only with keys: decision, confidence, workflow_bias, reason, evidence, riskFlags, focusHint. You may also include optional keys requires_clarification, clarification_slots, and adopted_artifact when clearly supported.",
+		"decision must be exactly one of offer_workflow, normal_prompt, or unclear.",
+		"Use offer_workflow when the user is directly asking to start, resume, refocus, or continue workflow-worthy repo work through the completion boundary, or explicitly asking to let /cook take over.",
+		"Use normal_prompt for ordinary questions, explanations, analysis-only requests, or direct agent requests that should stay in the main chat.",
 		"Use unclear for ambiguous approvals, short acknowledgements, or cases where false-positive routing risk is material.",
+		"workflow_bias must be exactly one of startup, resume, refocus, next_round, or unknown.",
+		"Use startup when there is no active workflow yet, resume when the user is clearly continuing the current workflow, refocus when the user is clearly switching the active workflow to a different goal, and next_round when the previous workflow is done and the user is starting a new round.",
+		"When decision is not offer_workflow, prefer workflow_bias=unknown unless a stronger routing hint is still useful for later debugging.",
 		"focusHint is optional, must stay short, and must never rewrite the workflow mission or invent scope.",
+		"When explicit user adoption of a recent plan or repo markdown artifact is evident, adopted_artifact may describe it with kind recent_plan|repo_markdown, path when known, and basis explicit_user_adoption.",
+		"requires_clarification may be true when chooser-style disambiguation is safer than guessing, and clarification_slots may list short needs such as goal, scope, or non_goal.",
 		"evidence and riskFlags must be arrays of short grounded strings.",
 	];
 	if (args.workflowContextLines?.length) lines.push("", "Canonical workflow context:", ...args.workflowContextLines);
@@ -225,24 +238,202 @@ export function buildCookTriggerClassifierPrompt(args: {
 	return lines.join("\n");
 }
 
-export function buildCookTriggerConfirmationActions(mainChatRerunGuidance: string): CookTriggerConfirmationActionItem[] {
-	return [
-		{
-			id: "start_cook",
-			label: "Start /cook",
-			description: "Let /cook take over before the primary agent starts implementation work.",
-		},
+function cookTriggerOfferCopyForBias(
+	workflowBias: CookTriggerWorkflowBias,
+	mainChatRerunGuidance: string,
+): { title: string; intro: string; startAction: CookTriggerConfirmationActionItem; sendAsNormalChat: CookTriggerConfirmationActionItem; cancel: CookTriggerConfirmationActionItem } {
+	switch (workflowBias) {
+		case "startup":
+			return {
+				title: "Start a completion workflow from the recent discussion?",
+				intro:
+					"This input looks like a startup handoff into the completion workflow. The shared /cook entry would initialize or continue the canonical workflow boundary only after you confirm.",
+				startAction: {
+					id: "start_workflow",
+					label: "Start workflow",
+					description: "Enter the shared /cook workflow entry from the recent discussion before the primary agent starts implementation work.",
+				},
+				sendAsNormalChat: {
+					id: "send_as_normal_chat",
+					label: "Send as normal chat",
+					description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+				},
+				cancel: {
+					id: "cancel",
+					label: "Cancel",
+					description: `Stop here without routing or replaying the original message. ${mainChatRerunGuidance}`,
+				},
+			};
+		case "resume":
+			return {
+				title: "Resume the current completion workflow?",
+				intro:
+					"This input looks like a resume handoff for the current completion workflow. The shared /cook entry would continue from canonical state only after you confirm.",
+				startAction: {
+					id: "start_workflow",
+					label: "Resume workflow",
+					description: "Resume the current canonical completion workflow through the shared /cook entry.",
+				},
+				sendAsNormalChat: {
+					id: "send_as_normal_chat",
+					label: "Send as normal chat",
+					description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+				},
+				cancel: {
+					id: "cancel",
+					label: "Cancel",
+					description: `Stop here without resuming or replaying the original message. ${mainChatRerunGuidance}`,
+				},
+			};
+		case "refocus":
+			return {
+				title: "Refocus the completion workflow from the recent discussion?",
+				intro:
+					"This input looks like a refocus handoff. The shared /cook entry would keep the existing chooser and confirmation semantics before any canonical workflow state is rewritten.",
+				startAction: {
+					id: "start_workflow",
+					label: "Refocus workflow",
+					description: "Review the recent discussion through the shared /cook entry and refocus the canonical workflow only if the follow-up confirmations agree.",
+				},
+				sendAsNormalChat: {
+					id: "send_as_normal_chat",
+					label: "Send as normal chat",
+					description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+				},
+				cancel: {
+					id: "cancel",
+					label: "Cancel",
+					description: `Stop here without refocusing or replaying the original message. ${mainChatRerunGuidance}`,
+				},
+			};
+		case "next_round":
+			return {
+				title: "Start the next completion workflow round from the recent discussion?",
+				intro:
+					"This input looks like a next-round handoff after a completed workflow. The shared /cook entry would preserve the same canonical workflow boundary while starting the next round only after you confirm.",
+				startAction: {
+					id: "start_workflow",
+					label: "Start next round",
+					description: "Start the next workflow round through the shared /cook entry using the recent discussion as the new focus.",
+				},
+				sendAsNormalChat: {
+					id: "send_as_normal_chat",
+					label: "Send as normal chat",
+					description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+				},
+				cancel: {
+					id: "cancel",
+					label: "Cancel",
+					description: `Stop here without starting a new workflow round or replaying the original message. ${mainChatRerunGuidance}`,
+				},
+			};
+		case "unknown":
+		default:
+			return {
+				title: "Let the completion workflow take over from the recent discussion?",
+				intro:
+					"This input looks like a natural-language handoff into the completion workflow. The shared /cook entry would keep the existing approval-only startup, continue, refocus, and next-round semantics before canonical state changes.",
+				startAction: {
+					id: "start_workflow",
+					label: "Start workflow",
+					description: "Enter the shared /cook workflow entry before the primary agent starts implementation work.",
+				},
+				sendAsNormalChat: {
+					id: "send_as_normal_chat",
+					label: "Send as normal chat",
+					description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+				},
+				cancel: {
+					id: "cancel",
+					label: "Cancel",
+					description: `Stop here without routing or replaying the original message. ${mainChatRerunGuidance}`,
+				},
+			};
+	}
+}
+
+export function buildCookTriggerConfirmationActions(
+	workflowBias: CookTriggerWorkflowBias,
+	mainChatRerunGuidance: string,
+): CookTriggerConfirmationActionItem[] {
+	const copy = cookTriggerOfferCopyForBias(workflowBias, mainChatRerunGuidance);
+	return [copy.startAction, copy.sendAsNormalChat, copy.cancel];
+}
+
+function summarizeAdoptedArtifact(adoptedArtifact: CookTriggerAdoptedArtifact | undefined): string | undefined {
+	if (!adoptedArtifact) return undefined;
+	const lines = [
+		`- kind: ${adoptedArtifact.kind}`,
+		`- basis: ${adoptedArtifact.basis}`,
+		`- title: ${adoptedArtifact.title}`,
+	];
+	if (adoptedArtifact.path) lines.push(`- path: ${adoptedArtifact.path}`);
+	if (adoptedArtifact.preview) lines.push(`- preview: ${adoptedArtifact.preview}`);
+	return lines.join("\n");
+}
+
+export function buildCookTriggerClarificationLayout(args: {
+	currentMission?: string;
+	candidateMission?: string;
+	workflowBiases: CookTriggerWorkflowBias[];
+	mainChatRerunGuidance: string;
+	adoptedArtifact?: CookTriggerAdoptedArtifact;
+}): CookTriggerClarificationLayout {
+	const actions: CookTriggerClarificationActionItem[] = [];
+	if (args.workflowBiases.includes("startup")) {
+		actions.push({
+			id: "route_startup",
+			label: "Start workflow",
+			description: "Treat this as a startup handoff into the shared /cook workflow from the recent discussion.",
+		});
+	}
+	if (args.workflowBiases.includes("resume")) {
+		actions.push({
+			id: "route_resume",
+			label: "Resume workflow",
+			description: "Keep the current canonical mission and resume the active workflow through the shared /cook entry.",
+		});
+	}
+	if (args.workflowBiases.includes("refocus")) {
+		actions.push({
+			id: "route_refocus",
+			label: "Refocus from recent discussion",
+			description: "Route into the shared /cook entry and keep its existing chooser + approval flow before any canonical state rewrite.",
+		});
+	}
+	if (args.workflowBiases.includes("next_round")) {
+		actions.push({
+			id: "route_next_round",
+			label: "Start next round",
+			description: "Treat this as a next-round handoff into the shared /cook entry after the finished workflow.",
+		});
+	}
+	actions.push(
 		{
-			id: "keep_chatting",
-			label: "Keep chatting",
-			description: "Send the original message to the primary agent instead.",
+			id: "send_as_normal_chat",
+			label: "Send as normal chat",
+			description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
 		},
 		{
 			id: "cancel",
 			label: "Cancel",
-			description: `Stop here without routing the message. ${mainChatRerunGuidance}`,
+			description: `Stop here without routing or replaying the original message. ${args.mainChatRerunGuidance}`,
 		},
-	];
+	);
+	return {
+		title: "Clarify how the completion workflow should proceed",
+		intro:
+			"This start-intent looks workflow-related, but not enough to safely choose startup, resume, refocus, or next-round automatically. Pick the minimal next step or cancel without changing canonical workflow state.",
+		currentMissionHeading: args.currentMission ? "Current mission" : undefined,
+		currentMissionBody: args.currentMission,
+		candidateMissionHeading: args.candidateMission ? "Recent-discussion candidate" : undefined,
+		candidateMissionBody: args.candidateMission,
+		adoptedArtifactHeading: args.adoptedArtifact ? "Adopted artifact" : undefined,
+		adoptedArtifactBody: summarizeAdoptedArtifact(args.adoptedArtifact),
+		actionsHeading: "Actions",
+		actions,
+		footer: "↑↓ navigate • enter select • esc cancel",
+	};
 }
 
 export function buildCookTriggerAssistConfirmationLayout(args: {
@@ -254,10 +445,10 @@ export function buildCookTriggerAssistConfirmationLayout(args: {
 			? args.classification.evidence.map((item) => `- ${item}`).join("\n")
 			: "- No additional evidence was captured beyond the current handoff signal.";
 	const riskBody = args.classification.riskFlags.length > 0 ? args.classification.riskFlags.map((item) => `- ${item}`).join("\n") : undefined;
+	const copy = cookTriggerOfferCopyForBias(args.classification.workflowBias, args.mainChatRerunGuidance);
 	return {
-		title: "Let /cook take over from the recent discussion?",
-		intro:
-			"This input looks like a natural-language handoff into the completion workflow. /cook would keep the existing approval-only startup, continue, refocus, and next-round semantics before canonical state changes.",
+		title: copy.title,
+		intro: copy.intro,
 		evidenceHeading: "Why it matched",
 		evidenceBody,
 		riskHeading: riskBody ? "Risk checks" : undefined,
@@ -265,7 +456,40 @@ export function buildCookTriggerAssistConfirmationLayout(args: {
 		focusHintHeading: args.classification.focusHint ? "Optional focus hint" : undefined,
 		focusHintBody: args.classification.focusHint,
 		actionsHeading: "Actions",
-		actions: buildCookTriggerConfirmationActions(args.mainChatRerunGuidance),
+		actions: [copy.startAction, copy.sendAsNormalChat, copy.cancel],
+		footer: "↑↓ navigate • enter select • esc cancel",
+	};
+}
+
+export function buildCookTriggerRecoveryLayout(args: {
+	failureLabel: string;
+	mainChatRerunGuidance: string;
+}): CookTriggerRecoveryLayout {
+	const actions: CookTriggerRecoveryActionItem[] = [
+		{
+			id: "retry_routing",
+			label: "Retry routing",
+			description: "Run the workflow-aware router classifier once more before deciding whether /cook should take over.",
+		},
+		{
+			id: "send_as_normal_chat",
+			label: "Send as normal chat",
+			description: "Replay the original message exactly once to the primary agent and bypass router interception for that replay.",
+		},
+		{
+			id: "cancel",
+			label: "Cancel",
+			description: `Stop here without routing or replaying the original message. ${args.mainChatRerunGuidance}`,
+		},
+	];
+	return {
+		title: "Router recovery needed before this prompt can continue",
+		intro:
+			"The workflow-aware router could not safely classify this prompt, so it stayed fail-closed instead of silently sending the prompt to the primary agent. Choose an explicit recovery path or cancel.",
+		failureHeading: "Router failure",
+		failureBody: args.failureLabel,
+		actionsHeading: "Actions",
+		actions,
 		footer: "↑↓ navigate • enter select • esc cancel",
 	};
 }
@@ -281,10 +505,62 @@ export function maybeWriteCookTriggerConfirmationSnapshot(
 	writeJsonSnapshot(snapshotPath, layout);
 }
 
+export function maybeWriteCookTriggerClarificationSnapshot(
+	layout: CookTriggerClarificationLayout,
+	snapshotPath: string | undefined,
+): void {
+	writeJsonSnapshot(snapshotPath, layout);
+}
+
+export function maybeWriteCookTriggerRecoverySnapshot(layout: CookTriggerRecoveryLayout, snapshotPath: string | undefined): void {
+	writeJsonSnapshot(snapshotPath, layout);
+}
+
 export function maybeWriteCookTriggerRoutingSnapshot(snapshot: Record<string, unknown>, snapshotPath: string | undefined): void {
 	writeJsonSnapshot(snapshotPath, snapshot);
 }
 
+function buildNaturalLanguageHandoffArtifactLines(adoptedArtifact: CookTriggerAdoptedArtifact | undefined): string[] {
+	if (!adoptedArtifact) return [];
+	const lines = [
+		`- adopted_artifact_kind: ${adoptedArtifact.kind}`,
+		`- adopted_artifact_basis: ${adoptedArtifact.basis}`,
+		`- adopted_artifact_title: ${adoptedArtifact.title}`,
+	];
+	if (adoptedArtifact.path) lines.push(`- adopted_artifact_path: ${adoptedArtifact.path}`);
+	if (adoptedArtifact.preview) lines.push(`- adopted_artifact_preview: ${adoptedArtifact.preview}`);
+	return lines;
+}
+
+function buildNaturalLanguageHandoffClarificationLines(
+	clarificationCapsule: CookNaturalLanguageHandoff["clarificationCapsule"] | undefined,
+): string[] {
+	if (!clarificationCapsule) return [];
+	const lines = [
+		`- clarification_selected_bias: ${clarificationCapsule.selectedWorkflowBias}`,
+		`- clarification_reason: ${clarificationCapsule.reason}`,
+	];
+	if (clarificationCapsule.goal) lines.push(`- clarification_goal: ${clarificationCapsule.goal}`);
+	if (clarificationCapsule.scope?.length) lines.push(`- clarification_scope: ${clarificationCapsule.scope.join(" | ")}`);
+	if (clarificationCapsule.nonGoal?.length) lines.push(`- clarification_non_goal: ${clarificationCapsule.nonGoal.join(" | ")}`);
+	if (clarificationCapsule.doneWhen?.length) lines.push(`- clarification_done_when: ${clarificationCapsule.doneWhen.join(" | ")}`);
+	return lines;
+}
+
+export function buildNaturalLanguageHandoffMetadataLines(handoff: CookNaturalLanguageHandoff | undefined): string[] {
+	if (!handoff) return [];
+	return [
+		"Natural-language handoff metadata:",
+		`- source: natural_language_handoff`,
+		`- preferred_routing_bias: ${handoff.preferredRoutingBias ?? "unknown"}`,
+		`- trigger_text: ${handoff.triggerText ?? "(none)"}`,
+		`- focus_hint: ${handoff.hintText ?? "(none)"}`,
+		...buildNaturalLanguageHandoffArtifactLines(handoff.adoptedArtifact),
+		...buildNaturalLanguageHandoffClarificationLines(handoff.clarificationCapsule),
+		"",
+	];
+}
+
 export function buildContextProposalConfirmationSelectItems(layout: ContextProposalConfirmationLayout) {
 	return layout.actions.map((action) => ({
 		value: action.id,

package/extensions/completion/role-runner.ts

@@ -121,18 +121,24 @@ const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
 const STARTUP_ANALYST_ROLE = "cook-proposal-analyst";
 const ANALYST_HEARTBEAT_MS = 5_000;
 const COOK_TRIGGER_CLASSIFIER_SYSTEM_PROMPT = [
-	"You classify whether the latest user input should hand control to the canonical /cook workflow before the primary agent starts implementation work.",
+	"You classify whether the latest user input should stay in the main chat or be intercepted by the workflow-aware router into the canonical /cook workflow before the primary agent starts implementation work.",
+	"Assume router mode reviews every non-bypass normal user turn. Do not require short trigger phrases or explicit /cook text before choosing offer_workflow.",
 	"Do not emit markdown, code fences, or commentary.",
-	"Return exactly one JSON object with keys: intent, confidence, reason, evidence, riskFlags, focusHint.",
-	"intent must be exactly one of route_to_cook, normal_prompt, or unclear.",
-	"Use route_to_cook only when the latest input is handing control from discussion into workflow execution or explicitly asking to let /cook take over.",
-	"Use normal_prompt for ordinary questions, explanations, or direct requests that should stay with the primary agent.",
+	"Return exactly one JSON object with keys: decision, confidence, workflow_bias, reason, evidence, riskFlags, focusHint. You may also include optional keys requires_clarification, clarification_slots, and adopted_artifact when clearly supported.",
+	"decision must be exactly one of offer_workflow, normal_prompt, or unclear.",
+	"Use offer_workflow when the latest input is directly asking to start, resume, refocus, or continue workflow-worthy repo work through the completion boundary, or explicitly asking to let /cook take over.",
+	"Use normal_prompt for ordinary questions, explanations, analysis-only requests, or direct requests that should stay with the primary agent.",
 	"Use unclear for ambiguous approvals, acknowledgements, or mixed signals where false-positive routing risk is material.",
+	"workflow_bias must be exactly one of startup, resume, refocus, next_round, or unknown.",
+	"Use startup when there is no active workflow yet, resume when the user is clearly continuing the current workflow, refocus when the user is clearly switching the active workflow to a different goal, and next_round when the previous workflow is done and the user is starting a new round.",
+	"When decision is not offer_workflow, prefer workflow_bias=unknown unless a stronger routing hint would still aid debugging.",
 	"confidence must be a number from 0 to 1.",
 	"reason must be a single concise sentence.",
 	"evidence must be an array of short grounded strings.",
 	"riskFlags must be an array of short machine-readable strings such as ambiguous-approval, possible-normal-agent-request, or active-workflow-refocus-risk.",
 	"focusHint is optional, must stay short, and must never rewrite the workflow mission or invent scope.",
+	"When explicit user adoption of a recent plan or repo markdown artifact is evident, adopted_artifact may describe it with kind recent_plan|repo_markdown, path when known, and basis explicit_user_adoption.",
+	"requires_clarification may be true when chooser-style disambiguation is safer than guessing, and clarification_slots may list short needs such as goal, scope, or non_goal.",
 	"Short acknowledgements like 好, 可以, ok, sure, or 那就這樣 should usually be unclear unless the surrounding context makes the handoff explicit.",
 ].join(" ");
 const COOK_TRIGGER_CLASSIFIER_TIMEOUT_MS = 10_000;
@@ -218,7 +224,7 @@ async function runContextProposalAnalystSubprocess(params: AnalyzeContextProposa
 	const rootKey = completionRootKey(undefined, cwd);
 	const prompt = buildContextProposalAnalystPromptFromEntries(projectName, recentEntries, params.workflowContextLines);
 	const systemPromptTemp = await writeTempFile(runCwd, "pi-cook-proposal-analyst-", CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT);
-	const args: string[] = ["--mode", "json", "-p", "--no-session", "--append-system-prompt", systemPromptTemp.filePath, "--model", modelArg, prompt];
+	const args: string[] = ["--mode", "json", "-p", "--no-session", "--no-extensions", "--append-system-prompt", systemPromptTemp.filePath, "--model", modelArg, prompt];
 	const invocation = getPiInvocation(args);
 	const liveActivity = createLiveRoleActivity(STARTUP_ANALYST_ROLE);
 	liveActivity.progress = "Analyzing recent discussion";
@@ -408,15 +414,33 @@ function parseCookTriggerClassification(raw: string): CookTriggerClassification
 		return undefined;
 	}
 	if (!isRecord(parsed)) return undefined;
-	const intent = asString(parsed.intent);
-	if (intent !== "route_to_cook" && intent !== "normal_prompt" && intent !== "unclear") return undefined;
+	const rawDecision = asString(parsed.decision ?? parsed.intent);
+	const decision =
+		rawDecision === "offer_workflow" || rawDecision === "normal_prompt" || rawDecision === "unclear"
+			? rawDecision
+			: rawDecision === "route_to_cook"
+				? "offer_workflow"
+				: undefined;
+	if (!decision) return undefined;
+	const rawWorkflowBias = asString(parsed.workflow_bias ?? parsed.workflowBias ?? parsed.routing_bias ?? parsed.routingBias);
+	const workflowBias =
+		rawWorkflowBias === "startup" ||
+		rawWorkflowBias === "resume" ||
+		rawWorkflowBias === "refocus" ||
+		rawWorkflowBias === "next_round" ||
+		rawWorkflowBias === "unknown"
+			? rawWorkflowBias
+			: decision === "offer_workflow" && rawDecision === "route_to_cook"
+				? "unknown"
+				: "unknown";
 	const evidence = localAsStringArray(parsed.evidence);
 	const riskFlags = localAsStringArray(parsed.riskFlags ?? parsed.risk_flags);
-	const reason = asString(parsed.reason) ?? asString(parsed.rationale) ?? evidence[0] ?? `Classifier returned ${intent}.`;
+	const reason = asString(parsed.reason) ?? asString(parsed.rationale) ?? evidence[0] ?? `Classifier returned ${decision}.`;
 	const focusHint = asString(parsed.focusHint ?? parsed.focus_hint);
 	return {
-		intent,
+		decision,
 		confidence: confidenceFromUnknown(parsed.confidence),
+		workflowBias,
 		reason,
 		focusHint,
 		evidence: evidence.length > 0 ? evidence : [reason],
@@ -440,7 +464,7 @@ async function runCookTriggerClassifierSubprocess(
 	const runCwd = findCompletionRoot(cwd) ?? findRepoRoot(cwd) ?? cwd;
 	const modelArg = contextProposalAnalystModelArg(params.ctx.model);
 	const systemPromptTemp = await writeTempFile(runCwd, "pi-cook-trigger-classifier-", COOK_TRIGGER_CLASSIFIER_SYSTEM_PROMPT);
-	const args: string[] = ["--mode", "json", "-p", "--no-session", "--append-system-prompt", systemPromptTemp.filePath];
+	const args: string[] = ["--mode", "json", "-p", "--no-session", "--no-extensions", "--append-system-prompt", systemPromptTemp.filePath];
 	if (modelArg) args.push("--model", modelArg);
 	args.push(params.prompt);
 	const invocation = getPiInvocation(args);

package/extensions/completion/types.ts

@@ -86,19 +86,30 @@ export type CompletionStatusSurface = {
 	liveDetailsLines?: string[];
 };
 
-export type NaturalLanguageCookTriggerMode = "off" | "assist" | "auto";
-export type CookTriggerIntent = "route_to_cook" | "normal_prompt" | "unclear";
+export type NaturalLanguageCookTriggerMode = "off" | "assist" | "router" | "auto";
+export type CookTriggerClassifierDecision = "offer_workflow" | "normal_prompt" | "unclear";
+export type CookTriggerWorkflowBias = "startup" | "resume" | "refocus" | "next_round" | "unknown";
 
 export type CookTriggerClassification = {
-	intent: CookTriggerIntent;
+	decision: CookTriggerClassifierDecision;
 	confidence: number;
+	workflowBias: CookTriggerWorkflowBias;
 	reason: string;
 	focusHint?: string;
 	evidence: string[];
 	riskFlags: string[];
 };
 
-export type CookTriggerConfirmationAction = "start_cook" | "keep_chatting" | "cancel";
+export type CookTriggerConfirmationAction = "start_workflow" | "send_as_normal_chat" | "cancel";
+export type CookTriggerClarificationAction =
+	| "route_startup"
+	| "route_resume"
+	| "route_refocus"
+	| "route_next_round"
+	| "send_as_normal_chat"
+	| "cancel";
+export type CookTriggerRecoveryAction = "retry_routing" | "send_as_normal_chat" | "cancel";
+export type CookTriggerAdoptedArtifactKind = "recent_plan" | "repo_markdown";
 
 export type CookTriggerConfirmationActionItem = {
 	id: CookTriggerConfirmationAction;
@@ -106,6 +117,12 @@ export type CookTriggerConfirmationActionItem = {
 	description: string;
 };
 
+export type CookTriggerClarificationActionItem = {
+	id: CookTriggerClarificationAction;
+	label: string;
+	description: string;
+};
+
 export type CookTriggerConfirmationLayout = {
 	title: string;
 	intro: string;
@@ -120,6 +137,61 @@ export type CookTriggerConfirmationLayout = {
 	footer: string;
 };
 
+export type CookTriggerClarificationCapsule = {
+	goal?: string;
+	scope?: string[];
+	nonGoal?: string[];
+	doneWhen?: string[];
+	selectedWorkflowBias: CookTriggerWorkflowBias;
+	reason: string;
+};
+
+export type CookTriggerAdoptedArtifact = {
+	kind: CookTriggerAdoptedArtifactKind;
+	basis: "explicit_user_adoption";
+	title: string;
+	path?: string;
+	preview?: string;
+};
+
+export type CookNaturalLanguageHandoff = {
+	preferredRoutingBias?: CookTriggerWorkflowBias;
+	triggerText?: string;
+	hintText?: string;
+	clarificationCapsule?: CookTriggerClarificationCapsule;
+	adoptedArtifact?: CookTriggerAdoptedArtifact;
+};
+
+export type CookTriggerClarificationLayout = {
+	title: string;
+	intro: string;
+	currentMissionHeading?: string;
+	currentMissionBody?: string;
+	candidateMissionHeading?: string;
+	candidateMissionBody?: string;
+	adoptedArtifactHeading?: string;
+	adoptedArtifactBody?: string;
+	actionsHeading: string;
+	actions: CookTriggerClarificationActionItem[];
+	footer: string;
+};
+
+export type CookTriggerRecoveryActionItem = {
+	id: CookTriggerRecoveryAction;
+	label: string;
+	description: string;
+};
+
+export type CookTriggerRecoveryLayout = {
+	title: string;
+	intro: string;
+	failureHeading?: string;
+	failureBody?: string;
+	actionsHeading: string;
+	actions: CookTriggerRecoveryActionItem[];
+	footer: string;
+};
+
 export type CookTriggerDecision = {
 	mode: NaturalLanguageCookTriggerMode;
 	action: "continue" | "handled" | "routed_to_cook";

package/package.json

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