@linimin/pi-letscook 0.1.50 → 0.1.52

package/extensions/completion/prompt-surfaces.ts

@@ -1,6 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { CompletionStateSnapshot, LiveRoleActivity } from "./types";
+import type {
+	CompletionStateSnapshot,
+	CookNaturalLanguageHandoff,
+	CookTriggerAdoptedArtifact,
+	CookTriggerClarificationActionItem,
+	CookTriggerClarificationLayout,
+	CookTriggerClassification,
+	CookTriggerConfirmationActionItem,
+	CookTriggerConfirmationLayout,
+	CookTriggerRecoveryActionItem,
+	CookTriggerRecoveryLayout,
+	CookTriggerWorkflowBias,
+	LiveRoleActivity,
+} from "./types";
 import type {
 	ContextProposal,
 	ContextProposalAnalysis,
@@ -187,6 +200,367 @@ export function maybeWriteContextProposalSnapshot(proposal: ContextProposal, sna
 	}
 }
 
+function writeJsonSnapshot(snapshotPath: string | undefined, value: unknown): void {
+	if (!snapshotPath) return;
+	try {
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		fs.writeFileSync(snapshotPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	} catch {
+		// ignore malformed or unwritable test snapshot paths
+	}
+}
+
+export function buildCookTriggerClassifierPrompt(args: {
+	projectName: string;
+	inputText: string;
+	recentDiscussion: string;
+	workflowContextLines?: string[];
+}): string {
+	const lines = [
+		`Project: ${args.projectName}`,
+		"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);
+	lines.push("", `Current input: ${args.inputText}`, "", "Recent discussion:", args.recentDiscussion || "(none)");
+	return lines.join("\n");
+}
+
+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: "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: "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: {
+	classification: CookTriggerClassification;
+	mainChatRerunGuidance: string;
+}): CookTriggerConfirmationLayout {
+	const evidenceBody =
+		args.classification.evidence.length > 0
+			? 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: copy.title,
+		intro: copy.intro,
+		evidenceHeading: "Why it matched",
+		evidenceBody,
+		riskHeading: riskBody ? "Risk checks" : undefined,
+		riskBody,
+		focusHintHeading: args.classification.focusHint ? "Optional focus hint" : undefined,
+		focusHintBody: args.classification.focusHint,
+		actionsHeading: "Actions",
+		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",
+	};
+}
+
+export function maybeWriteCookTriggerClassifierSnapshot(snapshot: Record<string, unknown>, snapshotPath: string | undefined): void {
+	writeJsonSnapshot(snapshotPath, snapshot);
+}
+
+export function maybeWriteCookTriggerConfirmationSnapshot(
+	layout: CookTriggerConfirmationLayout,
+	snapshotPath: string | undefined,
+): void {
+	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/proposal.ts

@@ -350,7 +350,7 @@ function contextHintEntry(hintText: string | undefined): RecentDiscussionEntry[]
 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;
 
-function hasRecentDiscussionImplementationIntent(text: string, stripCodeBlocksFn: (text: string) => string): boolean {
+export function hasRecentDiscussionImplementationIntent(text: string, stripCodeBlocksFn: (text: string) => string): boolean {
 	const cleaned = stripCodeBlocksFn(text).replace(/\r/g, " ").trim();
 	if (!cleaned) return false;
 	return hasStructuredContextProposalSignal(cleaned, stripCodeBlocksFn) || RECENT_DISCUSSION_IMPLEMENTATION_INTENT_REGEX.test(cleaned);