@linimin/pi-letscook 0.1.37 → 0.1.39

package/extensions/completion/index.ts

@@ -467,7 +467,7 @@ type ActiveWorkflowProposalAssessment = {
 	action: "continue" | "refocus" | "unclear";
 	currentMissionAnchor: string;
 	proposal?: ContextProposal;
-	reason: "matching_mission" | "clear_refocus" | "explicit_goal" | "missing_proposal" | "ambiguous_discussion";
+	reason: "matching_mission" | "clear_refocus" | "missing_proposal" | "ambiguous_discussion";
 };
 
 type ExistingWorkflowChooserOptions = {
@@ -539,8 +539,10 @@ 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 structured Mission/Scope/Constraints/Acceptance proposal. Add that structure in the main chat or, as a temporary compatibility shim, pass /cook <text>.";
+	"Bare /cook failed closed because recent discussion did not contain a clear structured Mission/Scope/Constraints/Acceptance proposal. Add that structure in the main chat and rerun bare /cook.";
 
 function buildCookCancellationMessage(prefix: string): string {
 	return `${prefix}. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
@@ -753,6 +755,88 @@ function matchContextProposalRoutingHint(
 	return label === "tasktype" ? { field: "taskType", value } : { field: "evaluationProfile", value };
 }
 
+const CONTEXT_PROPOSAL_GENERIC_PLANNING_MISSION_REGEX =
+	/(?:\b(?:start(?:ing)?|begin|continue|continu(?:e|ing)|resume|implement(?:ing)?|execute|execut(?:e|ing)|carry out|work on|ship|build(?:ing)?)\b.*\b(?:this|that|the|current|latest)\s+(?:plan|proposal|spec(?:ification)?|design(?: doc(?:ument)?)?|migration plan)\b|(?:開始|著手|繼續|继续|恢復|恢复)?(?:實作|实现|執行|执行|落地|完成)(?:這個|这个|此|該|该)?(?:方案|計畫|计划|提案|規劃|规划|設計|设计))/iu;
+const CONTEXT_PROPOSAL_PLANNING_ONLY_DELIVERABLE_REGEX =
+	/(?:\b(?:write|draft|prepare|create|produce|share|deliver|document|review)\b.*\b(?:plan|spec(?:ification)?|design(?: doc(?:ument)?)?|migration plan|proposal)\b|(?:撰寫|撰写|編寫|编写|起草|準備|准备|產出|产出|整理|分享|交付|審查|审查).*(?:計畫|计划|規格|规格|設計文件|设计文档|提案|方案))/iu;
+const CONTEXT_PROPOSAL_NO_CODE_DOCS_ONLY_REGEX =
+	/(?:\b(?:docs? only|documentation only|no code(?: changes?)?|without code(?: changes?)?|do not implement|don't implement|planning only|proposal only|spec only|design[- ]doc only|no runtime changes?)\b|(?:只改文件|僅文件|仅文件|不改(?:動)?代碼|不改代码|不要實作|不要实现|只規劃|只规划|僅規劃|仅规划|不改(?:動)?執行|不改运行))/iu;
+const CONTEXT_PROPOSAL_SUPPORT_ONLY_DOCS_REGEX =
+	/(?:^(?:update|edit|document|refresh|write|add)\s+(?:the\s+)?(?:readme|docs?|documentation)\b|^(?:更新|補充|补充|撰寫|撰写|新增)\s*(?:README|文件|文檔|文档))/iu;
+const CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX =
+	/(?:\b(?:normalize|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)\b|(?:修正|修復|修复|更新|新增|移除|恢復|恢复|重構|重构|調整|调整|正規化|规范化|規範化|过滤|過濾|分離|分离|刷新|替換|替换|抑制|對齊|对齐|實作|实现|落地|修補|修补|阻止|允許|允许|轉換|转换|保留|保持))/iu;
+
+function contextProposalBodyTexts(proposal: Pick<ContextProposal, "scope" | "constraints" | "acceptance">): string[] {
+	return [...proposal.scope, ...proposal.constraints, ...proposal.acceptance];
+}
+
+function isGenericPlanningMissionAnchor(text: string): boolean {
+	const normalized = normalizeMissionAnchorText(text);
+	if (!normalized) return false;
+	return CONTEXT_PROPOSAL_GENERIC_PLANNING_MISSION_REGEX.test(normalized);
+}
+
+function hasExplicitPlanningOnlyDeliverable(texts: string[]): boolean {
+	return texts.some((text) => CONTEXT_PROPOSAL_PLANNING_ONLY_DELIVERABLE_REGEX.test(normalizeProposalLine(text)));
+}
+
+function hasClearNoCodeOrDocsOnlySignal(texts: string[]): boolean {
+	return texts.some((text) => CONTEXT_PROPOSAL_NO_CODE_DOCS_ONLY_REGEX.test(normalizeProposalLine(text)));
+}
+
+function isSupportOnlyDocumentationItem(text: string): boolean {
+	return CONTEXT_PROPOSAL_SUPPORT_ONLY_DOCS_REGEX.test(normalizeProposalLine(text));
+}
+
+function isImplementationMissionSourceCandidate(text: string): boolean {
+	const normalized = normalizeProposalLine(text);
+	if (!normalized) return false;
+	if (hasExplicitPlanningOnlyDeliverable([normalized])) return false;
+	if (hasClearNoCodeOrDocsOnlySignal([normalized])) return false;
+	if (isSupportOnlyDocumentationItem(normalized)) return false;
+	return CONTEXT_PROPOSAL_IMPLEMENTATION_SOURCE_REGEX.test(normalized);
+}
+
+function hasSupportOnlyDocumentationDeliverable(proposal: Pick<ContextProposal, "scope" | "acceptance">): boolean {
+	const deliverableTexts = [...proposal.scope, ...proposal.acceptance].map((item) => normalizeProposalLine(item)).filter(Boolean);
+	if (deliverableTexts.length === 0) return false;
+	return deliverableTexts.every((item) => isSupportOnlyDocumentationItem(item));
+}
+
+function pickImplementationMissionSource(proposal: Pick<ContextProposal, "scope" | "constraints" | "acceptance">): string | undefined {
+	for (const item of proposal.scope) {
+		if (isImplementationMissionSourceCandidate(item)) return item;
+	}
+	for (const item of proposal.acceptance) {
+		if (isImplementationMissionSourceCandidate(item)) return item;
+	}
+	return undefined;
+}
+
+function finalizeContextProposal(proposal: ContextProposal, projectName: string): ContextProposal | undefined {
+	if (!isGenericPlanningMissionAnchor(proposal.mission)) return proposal;
+	const bodyTexts = contextProposalBodyTexts(proposal);
+	if (hasExplicitPlanningOnlyDeliverable(bodyTexts) || hasClearNoCodeOrDocsOnlySignal(bodyTexts) || hasSupportOnlyDocumentationDeliverable(proposal)) {
+		return proposal;
+	}
+	const missionSource = pickImplementationMissionSource(proposal);
+	if (!missionSource) return undefined;
+	const nextMission = assessMissionAnchor(missionSource, projectName).derived;
+	const normalizedNextMission = normalizeMissionAnchorText(nextMission);
+	if (!normalizedNextMission || isWeakMissionAnchor(normalizedNextMission)) return undefined;
+	if (missionAnchorsStrictlyEquivalent(nextMission, proposal.mission)) return proposal;
+	return {
+		...proposal,
+		mission: nextMission,
+		goalText: buildContextProposalGoalText({
+			mission: nextMission,
+			scope: proposal.scope,
+			constraints: proposal.constraints,
+			acceptance: proposal.acceptance,
+		}),
+	};
+}
+
 const MISSION_SCOPE_FILTER_STOPWORDS = new Set([
 	"a",
 	"an",
@@ -887,19 +971,14 @@ function shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal: ContextPr
 	);
 }
 
-function maybeWriteActiveWorkflowRoutingSnapshot(
-	assessment: ActiveWorkflowProposalAssessment,
-	options: { mode: "bare" | "explicit"; explicitGoal?: string },
-): void {
+function maybeWriteActiveWorkflowRoutingSnapshot(assessment: ActiveWorkflowProposalAssessment): void {
 	const snapshotPath = completionTestActiveWorkflowRoutingSnapshotPath();
 	if (!snapshotPath) return;
 	maybeWriteTestSnapshot(
 		snapshotPath,
 		`${JSON.stringify(
 			{
-				mode: options.mode,
-				explicitGoalProvided: Boolean(options.explicitGoal),
-				explicitGoal: options.explicitGoal ?? null,
+				mode: "bare",
 				action: assessment.action,
 				reason: assessment.reason,
 				currentMissionAnchor: assessment.currentMissionAnchor,
@@ -928,7 +1007,6 @@ const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
 	"risks must contain concrete failure modes or regressions that the later workflow should keep in view.",
 	"task_type and evaluation_profile should be candidate routing hints only; reuse the existing completion vocabulary when it clearly fits instead of inventing new schema names.",
 	"possible_noise should list discussion points that look stale, weakly related, or unsafe to promote into scope.",
-	"When an explicit goal is provided, keep the mission anchored to that goal instead of replacing it with a broader or different mission.",
 	"When discussion is insufficient, prefer empty arrays and a low confidence value over invention.",
 ].join(" ");
 
@@ -983,11 +1061,7 @@ function extractJsonObjectFromText(text: string): string | undefined {
 	return unfenced.slice(start, end + 1);
 }
 
-function parseContextProposalAnalystOutput(
-	raw: string,
-	projectName: string,
-	explicitGoal?: string,
-): ContextProposal | undefined {
+function parseContextProposalAnalystOutput(raw: string, projectName: string): ContextProposal | undefined {
 	const jsonText = extractJsonObjectFromText(raw);
 	if (!jsonText) return undefined;
 	let parsed: unknown;
@@ -997,8 +1071,7 @@ function parseContextProposalAnalystOutput(
 		return undefined;
 	}
 	if (!isRecord(parsed)) return undefined;
-	const explicit = explicitGoal ? parseContextProposal(explicitGoal, projectName) : undefined;
-	const missionSource = explicit?.mission ?? explicitGoal ?? asString(parsed.mission);
+	const missionSource = asString(parsed.mission);
 	if (!missionSource) return undefined;
 	const assessment = assessMissionAnchor(missionSource, projectName);
 	const normalizedMission = normalizeMissionAnchorText(missionSource);
@@ -1007,31 +1080,28 @@ function parseContextProposalAnalystOutput(
 	const scope = uniqueProposalItems(asStringArray(parsed.scope));
 	const constraints = uniqueProposalItems(asStringArray(parsed.constraints));
 	const acceptance = uniqueProposalItems(asStringArray(parsed.acceptance));
-	const analysis = mergeContextProposalAnalysis(
-		[
-			explicit?.analysis,
-			buildContextProposalAnalysis({
-				taskType: parsed.task_type ?? parsed.taskType,
-				evaluationProfile: parsed.evaluation_profile ?? parsed.evaluationProfile,
-				critique: asStringArray(parsed.critique),
-				risks: asStringArray(parsed.risks ?? parsed.risk),
-				possibleNoise: asStringArray(parsed.possible_noise ?? parsed.possibleNoise),
-				hintTexts: [raw, mission, ...scope, ...constraints, ...acceptance],
-			}),
-		],
-		[explicitGoal ?? "", raw, mission, ...scope, ...constraints, ...acceptance],
-	);
+	const analysis = buildContextProposalAnalysis({
+		taskType: parsed.task_type ?? parsed.taskType,
+		evaluationProfile: parsed.evaluation_profile ?? parsed.evaluationProfile,
+		critique: asStringArray(parsed.critique),
+		risks: asStringArray(parsed.risks ?? parsed.risk),
+		possibleNoise: asStringArray(parsed.possible_noise ?? parsed.possibleNoise),
+		hintTexts: [raw, mission, ...scope, ...constraints, ...acceptance],
+	});
 	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview: raw.replace(/\s+/g, " ").trim(),
-		source: "analyst",
-	};
+	return finalizeContextProposal(
+		{
+			mission,
+			scope,
+			constraints,
+			acceptance,
+			analysis,
+			goalText,
+			basisPreview: raw.replace(/\s+/g, " ").trim(),
+			source: "analyst",
+		},
+		projectName,
+	);
 }
 
 function contextProposalAnalystModelArg(model: unknown): string | undefined {
@@ -1041,17 +1111,9 @@ function contextProposalAnalystModelArg(model: unknown): string | undefined {
 	return provider && id ? `${provider}/${id}` : undefined;
 }
 
-function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[], explicitGoal?: string): string {
+function buildContextProposalAnalystPrompt(projectName: string, recentEntries: RecentDiscussionEntry[]): string {
 	const discussion = serializeRecentDiscussionEntries(recentEntries);
-	return [
-		`Project: ${projectName}`,
-		explicitGoal
-			? `Explicit goal (keep this mission anchor):\n${explicitGoal}`
-			: "Explicit goal: none provided; infer the current mission from the discussion.",
-		"",
-		"Recent discussion:",
-		discussion,
-	].join("\n");
+	return [`Project: ${projectName}`, "Infer the current mission from the discussion.", "", "Recent discussion:", discussion].join("\n");
 }
 
 function contextProposalAnalystProgressLines(activity: LiveRoleActivity): string[] {
@@ -1080,14 +1142,13 @@ async function runContextProposalAnalystSubprocess(
 	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any },
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
-	explicitGoal?: 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, explicitGoal);
+	const prompt = buildContextProposalAnalystPrompt(projectName, recentEntries);
 	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];
@@ -1189,18 +1250,17 @@ async function analyzeContextProposalWithAgent(
 	ctx: { cwd: string; hasUI: boolean; ui: any; model?: any; modelRegistry?: any },
 	projectName: string,
 	recentEntries: RecentDiscussionEntry[],
-	explicitGoal?: string,
 ): Promise<ContextProposal | undefined> {
 	if (shouldDisableContextProposalAnalyst()) return undefined;
 	const testOutput = completionTestContextProposalAnalystOutput();
 	if (testOutput) {
-		return parseContextProposalAnalystOutput(testOutput, projectName, explicitGoal);
+		return parseContextProposalAnalystOutput(testOutput, projectName);
 	}
 	if (recentEntries.length === 0) return undefined;
 	try {
-		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries, explicitGoal);
+		const raw = await runContextProposalAnalystSubprocess(ctx, projectName, recentEntries);
 		if (!raw) return undefined;
-		return parseContextProposalAnalystOutput(raw, projectName, explicitGoal);
+		return parseContextProposalAnalystOutput(raw, projectName);
 	} catch (error) {
 		console.warn("[completion] context proposal analyst failed", error);
 		return undefined;
@@ -1562,16 +1622,19 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 		hintTexts: [cleaned, mission, ...scope, ...constraints, ...acceptance, ...critique, ...risks],
 	});
 	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview,
-		source: "session",
-	};
+	return finalizeContextProposal(
+		{
+			mission,
+			scope,
+			constraints,
+			acceptance,
+			analysis,
+			goalText,
+			basisPreview,
+			source: "session",
+		},
+		projectName,
+	);
 }
 
 function hasStructuredContextProposalSignal(text: string): boolean {
@@ -1627,7 +1690,12 @@ function parseStrictStructuredSessionProposal(text: string, projectName: string)
 
 	const proposal = parseContextProposal(cleaned, projectName);
 	if (!proposal) return undefined;
-	if (normalizeMissionAnchorText(proposal.mission) !== distinctMissionAnchors[0]) return undefined;
+	if (
+		normalizeMissionAnchorText(proposal.mission) !== distinctMissionAnchors[0] &&
+		!isGenericPlanningMissionAnchor(distinctMissionAnchors[0])
+	) {
+		return undefined;
+	}
 	if (proposal.scope.length === 0 || proposal.constraints.length === 0 || proposal.acceptance.length === 0) return undefined;
 	return { ...proposal, source: "session" };
 }
@@ -1648,58 +1716,17 @@ function extractContextProposalFromStructuredSession(
 async function extractContextProposalFromSession(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
-	explicitGoal?: string,
 ): Promise<ContextProposal | undefined> {
 	const recentEntries = collectRecentDiscussionEntries(ctx);
-	return (await analyzeContextProposalWithAgent(ctx, projectName, recentEntries, explicitGoal)) ??
+	return (await analyzeContextProposalWithAgent(ctx, projectName, recentEntries)) ??
 		extractContextProposalFromStructuredSession(recentEntries, projectName);
 }
 
-async function buildGoalAnchoredContextProposal(
-	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
-	goal: string,
-	projectName: string,
-): Promise<ContextProposal> {
-	const explicit = parseContextProposal(goal, projectName);
-	const sessionProposal = await extractContextProposalFromSession(ctx, projectName, goal);
-	const missionSource = explicit?.mission ?? goal;
-	const assessment = assessMissionAnchor(missionSource, projectName);
-	const mission = assessment.derived;
-	const mergeSessionBody = sessionProposal?.source === "analyst";
-	const explicitScope = explicit?.scope ?? [];
-	const sessionScope = mergeSessionBody
-		? (sessionProposal?.scope ?? []).filter((item) => isSessionScopeItemMissionRelevant(item, mission))
-		: [];
-	const sessionConstraints = mergeSessionBody ? sessionProposal?.constraints ?? [] : [];
-	const sessionAcceptance = mergeSessionBody ? sessionProposal?.acceptance ?? [] : [];
-	const scope = uniqueProposalItems([...explicitScope, ...sessionScope]);
-	const constraints = uniqueProposalItems([...(explicit?.constraints ?? []), ...sessionConstraints]);
-	const acceptance = uniqueProposalItems([...(explicit?.acceptance ?? []), ...sessionAcceptance]);
-	const analysis = mergeContextProposalAnalysis(
-		[explicit?.analysis, sessionProposal?.analysis],
-		[goal, mission, ...(sessionProposal?.analysis.possibleNoise ?? []), ...scope, ...constraints, ...acceptance],
-	);
-	const goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
-	return {
-		mission,
-		scope,
-		constraints,
-		acceptance,
-		analysis,
-		goalText,
-		basisPreview: sessionProposal?.basisPreview ?? explicit?.basisPreview ?? goal,
-		source: sessionProposal?.source ?? explicit?.source ?? "session",
-	};
-}
-
 async function deriveCookContextProposal(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	projectName: string,
-	explicitGoal?: string,
 ): Promise<ContextProposal | undefined> {
-	return explicitGoal
-		? await buildGoalAnchoredContextProposal(ctx, explicitGoal, projectName)
-		: await extractContextProposalFromSession(ctx, projectName);
+	return await extractContextProposalFromSession(ctx, projectName);
 }
 
 async function confirmContextProposal(
@@ -1975,44 +2002,37 @@ function buildEvaluationRoleReminderText(snapshot: CompletionStateSnapshot, role
 async function assessActiveWorkflowProposalRouting(
 	ctx: { cwd: string; hasUI: boolean; ui: any; sessionManager: any; model?: any; modelRegistry?: any },
 	snapshot: CompletionStateSnapshot,
-	explicitGoal?: string,
 ): Promise<ActiveWorkflowProposalAssessment> {
 	const currentMission = currentMissionAnchor(snapshot);
 	const projectName = path.basename(snapshot.files.root);
-	const proposal = explicitGoal
-		? await deriveCookContextProposal(ctx, projectName, explicitGoal)
-		: await deriveCookContextProposal(ctx, projectName);
-	const mode = explicitGoal ? "explicit" : "bare";
+	const proposal = await deriveCookContextProposal(ctx, projectName);
 	if (!proposal) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "unclear",
 			currentMissionAnchor: currentMission,
 			reason: "missing_proposal",
 		};
-		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 		return assessment;
 	}
-	const missionsMatch = explicitGoal
-		? missionAnchorsStrictlyEquivalent(currentMission, proposal.mission)
-		: missionAnchorsLikelyEquivalent(currentMission, proposal.mission);
-	if (missionsMatch) {
+	if (missionAnchorsLikelyEquivalent(currentMission, proposal.mission)) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "continue",
 			currentMissionAnchor: currentMission,
 			proposal,
 			reason: "matching_mission",
 		};
-		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 		return assessment;
 	}
-	if (explicitGoal || shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal)) {
+	if (shouldTreatBareActiveWorkflowProposalAsClearRefocus(proposal)) {
 		const assessment: ActiveWorkflowProposalAssessment = {
 			action: "refocus",
 			currentMissionAnchor: currentMission,
 			proposal,
-			reason: explicitGoal ? "explicit_goal" : "clear_refocus",
+			reason: "clear_refocus",
 		};
-		maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+		maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 		return assessment;
 	}
 	const assessment: ActiveWorkflowProposalAssessment = {
@@ -2021,7 +2041,7 @@ async function assessActiveWorkflowProposalRouting(
 		proposal,
 		reason: "ambiguous_discussion",
 	};
-	maybeWriteActiveWorkflowRoutingSnapshot(assessment, { mode, explicitGoal });
+	maybeWriteActiveWorkflowRoutingSnapshot(assessment);
 	return assessment;
 }
 
@@ -4050,11 +4070,14 @@ 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 explicitGoal = args.trim();
-			let goal = explicitGoal;
+			const inlineArgs = args.trim();
+			if (inlineArgs) {
+				emitCommandText(ctx, COOK_INLINE_ARG_REJECTION_MESSAGE, "info");
+				return;
+			}
+			let goal: string | undefined;
 			const cwd = getCtxCwd(ctx);
 			let snapshot = await loadCompletionSnapshot(cwd);
-			const hadSnapshot = Boolean(snapshot);
 			const workflowDone = isWorkflowDone(snapshot);
 			let kickoffIntent: "auto" | "continue" | "refocus" = "auto";
 			let kickoffMissionAnchor = snapshot ? currentMissionAnchor(snapshot) : undefined;
@@ -4063,40 +4086,21 @@ export default function completionExtension(pi: ExtensionAPI) {
 			if (!snapshot) {
 				const root = findRepoRoot(cwd) ?? cwd;
 				const projectName = path.basename(root);
-				if (!goal) {
-					const proposal = await deriveCookContextProposal(ctx, projectName);
-					if (!proposal) {
-						emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(), "info");
-						return;
-					}
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start a completion workflow from the recent discussion?",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal"), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffMissionAnchor = decision.missionAnchor;
-					kickoffAnalysis = decision.analysis;
-				} else {
-					const proposal = await deriveCookContextProposal(ctx, projectName, goal);
-					if (!proposal) {
-						emitCommandText(ctx, "Failed to derive a workflow startup proposal from this goal.", "error");
-						return;
-					}
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start a completion workflow from this goal?",
-						nonInteractiveBehavior: "accept",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled workflow startup proposal"), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffMissionAnchor = decision.missionAnchor;
-					kickoffAnalysis = decision.analysis;
+				const proposal = await deriveCookContextProposal(ctx, projectName);
+				if (!proposal) {
+					emitCommandText(ctx, buildCookStructuredDiscussionFailureMessage(), "info");
+					return;
+				}
+				const decision = await confirmContextProposal(ctx, proposal, {
+					title: "Start a completion workflow from the recent discussion?",
+				});
+				if (!decision) {
+					emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal"), "info");
+					return;
 				}
+				goal = decision.goalText;
+				kickoffMissionAnchor = decision.missionAnchor;
+				kickoffAnalysis = decision.analysis;
 				const startupRouting = finalizeContextProposalAnalysis(kickoffAnalysis, [goal ?? kickoffMissionAnchor ?? projectName]);
 				const created = await scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName, {
 					analysis: startupRouting,
@@ -4174,73 +4178,6 @@ export default function completionExtension(pi: ExtensionAPI) {
 				}
 			}
 			kickoffMissionAnchor = kickoffMissionAnchor ?? currentMissionAnchor(snapshot);
-			if (hadSnapshot && explicitGoal) {
-				if (workflowDone) {
-					const projectName = path.basename(snapshot.files.root);
-					const proposal = await deriveCookContextProposal(ctx, projectName, goal);
-					if (!proposal) {
-						emitCommandText(ctx, "Failed to derive the next workflow round proposal from this goal.", "error");
-						return;
-					}
-					const decision = await confirmContextProposal(ctx, proposal, {
-						title: "Start the next workflow round from this goal?",
-						nonInteractiveBehavior: "accept",
-					});
-					if (!decision) {
-						emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal"), "info");
-						return;
-					}
-					goal = decision.goalText;
-					kickoffIntent = "refocus";
-					kickoffMissionAnchor = decision.missionAnchor;
-					await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText, decision.analysis);
-					snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-					emitCommandText(ctx, `Started a new completion workflow round from explicit goal: ${decision.missionAnchor}`, "info");
-				} else {
-					const assessment = await assessActiveWorkflowProposalRouting(ctx, snapshot, goal);
-					if (!assessment.proposal) {
-						emitCommandText(ctx, "Failed to derive the replacement workflow proposal from this goal.", "error");
-						return;
-					}
-					if (assessment.action === "continue") {
-						kickoffIntent = "continue";
-						kickoffMissionAnchor = assessment.currentMissionAnchor;
-						if (normalizeMissionAnchorText(goal) !== normalizeMissionAnchorText(assessment.currentMissionAnchor)) {
-							emitCommandText(ctx, `Continuing existing workflow without changing mission anchor: ${assessment.currentMissionAnchor}`, "info");
-						}
-					} else {
-						const decision = await confirmExistingWorkflowProposal(ctx, snapshot, assessment.proposal, { comparison: "strict" });
-						if (!decision) {
-							emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "info");
-							return;
-						}
-						kickoffIntent = decision.action;
-						kickoffMissionAnchor = decision.currentMissionAnchor;
-						if (decision.action === "refocus") {
-							const proposalDecision = await confirmContextProposal(ctx, assessment.proposal, {
-								title: "Start the replacement workflow from this goal?",
-								nonInteractiveBehavior: "accept",
-							});
-							if (!proposalDecision) {
-								emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal"), "info");
-								return;
-							}
-							goal = proposalDecision.goalText;
-							await refocusCompletionMission(
-								snapshot,
-								proposalDecision.missionAnchor,
-								proposalDecision.goalText,
-								proposalDecision.analysis,
-							);
-							snapshot = (await loadCompletionSnapshot(snapshot.files.root)) ?? snapshot;
-							kickoffMissionAnchor = proposalDecision.missionAnchor;
-							emitCommandText(ctx, `Refocused completion mission to: ${proposalDecision.missionAnchor}`, "info");
-						} else if (normalizeMissionAnchorText(goal) !== normalizeMissionAnchorText(decision.currentMissionAnchor)) {
-							emitCommandText(ctx, `Continuing existing workflow without changing mission anchor: ${decision.currentMissionAnchor}`, "info");
-						}
-					}
-				}
-			}
 			pi.setSessionName(`completion: ${kickoffMissionAnchor.slice(0, 60)}`);
 			const kickoffPrompt = completionKickoff(
 				goal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linimin/pi-letscook",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "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/active-slice-contract-test.sh

@@ -5,6 +5,45 @@ PKG_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 TMPDIR="$(mktemp -d)"
 trap 'rm -rf "$TMPDIR"' EXIT
 
+write_session() {
+  local session_path="$1"
+  local cwd="$2"
+  local text="$3"
+  python3 - "$session_path" "$cwd" "$text" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+session_path = Path(sys.argv[1])
+cwd = sys.argv[2]
+text = sys.argv[3]
+session_path.parent.mkdir(parents=True, exist_ok=True)
+entries = [
+    {
+        "type": "session",
+        "version": 3,
+        "id": "11111111-1111-4111-8111-111111111111",
+        "timestamp": "2026-01-01T00:00:00.000Z",
+        "cwd": cwd,
+    },
+    {
+        "type": "message",
+        "id": "a1b2c3d4",
+        "parentId": None,
+        "timestamp": "2026-01-01T00:00:01.000Z",
+        "message": {
+            "role": "user",
+            "content": text,
+            "timestamp": 1767225601000,
+        },
+    },
+]
+with session_path.open('w', encoding='utf-8') as fh:
+    for entry in entries:
+        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+PY
+}
+
 cd "$PKG_ROOT"
 
 node <<'NODE'
@@ -46,12 +85,17 @@ NODE
 
 ROOT="$TMPDIR/repo"
 PROMPT="$TMPDIR/resume-prompt.txt"
+BOOTSTRAP_SESSION="$TMPDIR/session-active-slice-bootstrap.jsonl"
+BOOTSTRAP_DISCUSSION=$'Mission: Exercise active-slice contract parity.\nScope:\n- Bootstrap canonical completion files for the active-slice contract fixture.\nConstraints:\n- Use supported bare /cook startup only.\nAcceptance:\n- Materialize canonical files before the fixture rewrites them.'
 mkdir -p "$ROOT"
 cd "$ROOT"
 git init -q
+write_session "$BOOTSTRAP_SESSION" "$ROOT" "$BOOTSTRAP_DISCUSSION"
 
+PI_COMPLETION_CONTEXT_PROPOSAL_ACTION=accept \
+PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST=1 \
 PI_COMPLETION_SKIP_DRIVER_KICKOFF=1 \
-pi -e "$PKG_ROOT" -p "/cook active-slice contract fixture" \
+pi --session "$BOOTSTRAP_SESSION" -e "$PKG_ROOT" -p "/cook" \
   >"$TMPDIR/pi-active-slice-bootstrap.out" 2>"$TMPDIR/pi-active-slice-bootstrap.err"
 
 python3 - <<'PY'