@linimin/pi-letscook 0.1.29 → 0.1.31

package/extensions/completion/index.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import * as roleReporting from "./role-reporting.js";
 import { StringEnum } from "@mariozechner/pi-ai";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { DynamicBorder, parseFrontmatter } from "@mariozechner/pi-coding-agent";
@@ -30,6 +31,11 @@ const PACKAGE_REFERENCE_PATH = PACKAGE_ROOT
 const PACKAGE_AGENTS_DIR = PACKAGE_ROOT ? path.join(PACKAGE_ROOT, "agents") : undefined;
 const SKILL_PATH = PACKAGE_SKILL_PATH ?? path.join(AGENT_HOME, "skills", "completion-protocol", "SKILL.md");
 const REFERENCE_PATH = PACKAGE_REFERENCE_PATH ?? path.join(AGENT_HOME, "skills", "completion-protocol", "references", "completion.md");
+const DEFAULT_TASK_TYPE = "completion-workflow";
+const DEFAULT_EVALUATION_PROFILE = "completion-rubric-v1";
+const RUBRIC_EVALUATION_ROLES = ["completion-reviewer", "completion-auditor", "completion-stop-judge"] as const;
+
+type RubricEvaluationRole = (typeof RUBRIC_EVALUATION_ROLES)[number];
 
 type CompletionRole = (typeof ROLE_NAMES)[number];
 type JsonRecord = Record<string, unknown>;
@@ -108,16 +114,27 @@ type CompletionStatusSurface = {
 	liveDetailsLines?: string[];
 };
 
+type ContextProposalAnalysis = {
+	taskType?: string;
+	evaluationProfile?: string;
+	critique: string[];
+	risks: string[];
+	possibleNoise: string[];
+};
+
 type ContextProposal = {
 	mission: string;
 	scope: string[];
 	constraints: string[];
 	acceptance: string[];
+	analysis: ContextProposalAnalysis;
 	goalText: string;
 	basisPreview: string;
 	source: "session" | "analyst";
 };
 
+type ContextProposalSection = "mission" | "scope" | "constraints" | "acceptance" | "critique" | "risks";
+
 type RecentDiscussionEntry = {
 	role: "user" | "assistant" | "custom" | "summary";
 	text: string;
@@ -126,6 +143,7 @@ type RecentDiscussionEntry = {
 type ContextProposalDecision = {
 	missionAnchor: string;
 	goalText: string;
+	analysis: ContextProposalAnalysis;
 };
 
 type ContextProposalConfirmAction = "start" | "edit" | "cancel";
@@ -141,6 +159,10 @@ type ContextProposalConfirmationLayout = {
 	intro: string;
 	proposalHeading: string;
 	proposalBody: string;
+	critiqueHeading?: string;
+	critiqueBody?: string;
+	routingHeading?: string;
+	routingBody?: string;
 	actionsHeading: string;
 	actions: ContextProposalConfirmationActionItem[];
 	footer: string;
@@ -499,6 +521,28 @@ function completionTestContextProposalUiSnapshotPath(): string | undefined {
 	return asString(process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_PATH);
 }
 
+function completionTestContextProposalSnapshotPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_PATH);
+}
+
+function completionTestDriverPromptPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_DRIVER_PROMPT_PATH);
+}
+
+function completionTestSystemReminderPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_SYSTEM_REMINDER_PATH);
+}
+
+function maybeWriteTestSnapshot(targetPath: string | undefined, content: string): void {
+	if (!targetPath) return;
+	try {
+		fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+		fs.writeFileSync(targetPath, content, "utf8");
+	} catch {
+		// ignore malformed or unwritable test snapshot paths
+	}
+}
+
 function shouldDisableContextProposalAnalyst(): boolean {
 	return process.env.PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST === "1";
 }
@@ -541,7 +585,7 @@ function normalizeProposalLine(line: string): string {
 		.trim();
 }
 
-function detectProposalSection(line: string): "mission" | "scope" | "constraints" | "acceptance" | undefined {
+function detectProposalSection(line: string): ContextProposalSection | undefined {
 	const normalized = normalizeProposalLine(line)
 		.toLowerCase()
 		.replace(/[:：]$/, "")
@@ -551,12 +595,12 @@ function detectProposalSection(line: string): "mission" | "scope" | "constraints
 	if (["scope", "plan", "steps", "implementation", "範圍", "范围", "實作", "实现", "步驟", "步骤"].includes(normalized)) return "scope";
 	if (["constraints", "constraint", "guardrails", "non-goals", "限制", "約束", "约束", "非目標", "非目标"].includes(normalized)) return "constraints";
 	if (["acceptance", "acceptance criteria", "deliverables", "verification", "驗收", "验收", "交付", "驗證", "验证"].includes(normalized)) return "acceptance";
+	if (["critique", "critic", "concerns", "concern", "warnings", "warning", "notes", "note", "評論", "评论", "提醒"].includes(normalized)) return "critique";
+	if (["risk", "risks", "hazards", "hazard", "failure modes", "failure mode", "風險", "风险"].includes(normalized)) return "risks";
 	return undefined;
 }
 
-function matchInlineProposalSection(
-	line: string,
-): { section: "mission" | "scope" | "constraints" | "acceptance"; content: string } | undefined {
+function matchInlineProposalSection(line: string): { section: ContextProposalSection; content: string } | undefined {
 	const normalized = normalizeProposalLine(line);
 	const match = normalized.match(/^([^:：]+)[:：]\s*(.+)$/u);
 	if (!match) return undefined;
@@ -595,6 +639,113 @@ function uniqueProposalItems(items: string[]): string[] {
 	return result;
 }
 
+function normalizeContextProposalHint(value: unknown): string | undefined {
+	const normalized = asString(value)?.replace(/\s+/g, " ").trim();
+	return normalized || undefined;
+}
+
+function normalizeContextProposalTaskTypeHint(value: unknown): string | undefined {
+	const normalized = normalizeContextProposalHint(value);
+	if (!normalized) return undefined;
+	const canonical = normalized.toLowerCase().replace(/[\s/]+/g, "-");
+	return canonical === DEFAULT_TASK_TYPE ? DEFAULT_TASK_TYPE : normalized;
+}
+
+function normalizeContextProposalEvaluationProfileHint(value: unknown): string | undefined {
+	const normalized = normalizeContextProposalHint(value);
+	if (!normalized) return undefined;
+	const canonical = normalized.toLowerCase().replace(/[\s/]+/g, "-");
+	return canonical === DEFAULT_EVALUATION_PROFILE ? DEFAULT_EVALUATION_PROFILE : normalized;
+}
+
+function inferContextProposalTaskType(texts: string[]): string | undefined {
+	const corpus = texts
+		.map((text) => normalizeProposalLine(text).toLowerCase())
+		.filter(Boolean)
+		.join("\n");
+	if (!corpus) return undefined;
+	return /(completion|\/cook|\/complete|\.agent|slice|reground|reviewer|auditor|stop judge|stop-judge|workflow)/i.test(corpus)
+		? DEFAULT_TASK_TYPE
+		: undefined;
+}
+
+function inferContextProposalEvaluationProfile(texts: string[], taskType?: string): string | undefined {
+	const corpus = texts
+		.map((text) => normalizeProposalLine(text).toLowerCase())
+		.filter(Boolean)
+		.join("\n");
+	if (!corpus) return undefined;
+	if (
+		/(rubric|evaluation[_\s-]*profile|pass\|concern\|fail|contract coverage|correctness risk|verification evidence|docs\/state parity|reviewer|auditor|stop judge|stop-judge)/i.test(
+			corpus,
+		)
+	) {
+		return DEFAULT_EVALUATION_PROFILE;
+	}
+	return taskType === DEFAULT_TASK_TYPE && /(completion|\/cook|\/complete|slice|workflow|review|audit)/i.test(corpus)
+		? DEFAULT_EVALUATION_PROFILE
+		: undefined;
+}
+
+function buildContextProposalAnalysis(args: {
+	taskType?: unknown;
+	evaluationProfile?: unknown;
+	critique?: string[];
+	risks?: string[];
+	possibleNoise?: string[];
+	hintTexts?: string[];
+}): ContextProposalAnalysis {
+	const critique = uniqueProposalItems(args.critique ?? []);
+	const risks = uniqueProposalItems(args.risks ?? []);
+	const possibleNoise = uniqueProposalItems(args.possibleNoise ?? []);
+	const hintTexts = [...(args.hintTexts ?? []), ...critique, ...risks, ...possibleNoise];
+	const taskType = normalizeContextProposalTaskTypeHint(args.taskType) ?? inferContextProposalTaskType(hintTexts);
+	const evaluationProfile =
+		normalizeContextProposalEvaluationProfileHint(args.evaluationProfile) ??
+		inferContextProposalEvaluationProfile(hintTexts, taskType);
+	return {
+		taskType,
+		evaluationProfile,
+		critique,
+		risks,
+		possibleNoise,
+	};
+}
+
+function mergeContextProposalAnalysis(
+	sources: Array<ContextProposalAnalysis | undefined>,
+	hintTexts: string[] = [],
+): ContextProposalAnalysis {
+	const critique = uniqueProposalItems(sources.flatMap((source) => source?.critique ?? []));
+	const risks = uniqueProposalItems(sources.flatMap((source) => source?.risks ?? []));
+	const possibleNoise = uniqueProposalItems(sources.flatMap((source) => source?.possibleNoise ?? []));
+	const taskType =
+		sources.map((source) => source?.taskType).find((value): value is string => Boolean(value)) ??
+		inferContextProposalTaskType([...hintTexts, ...critique, ...risks, ...possibleNoise]);
+	const evaluationProfile =
+		sources.map((source) => source?.evaluationProfile).find((value): value is string => Boolean(value)) ??
+		inferContextProposalEvaluationProfile([...hintTexts, ...critique, ...risks, ...possibleNoise], taskType);
+	return {
+		taskType,
+		evaluationProfile,
+		critique,
+		risks,
+		possibleNoise,
+	};
+}
+
+function matchContextProposalRoutingHint(
+	line: string,
+): { field: "taskType" | "evaluationProfile"; value: string } | undefined {
+	const normalized = normalizeProposalLine(line);
+	const match = normalized.match(/^(task[\s_-]*type|evaluation[\s_-]*profile)[:：]\s*(.+)$/iu);
+	if (!match) return undefined;
+	const label = match[1].toLowerCase().replace(/[\s_-]+/g, "");
+	const value = match[2].trim();
+	if (!value) return undefined;
+	return label === "tasktype" ? { field: "taskType", value } : { field: "evaluationProfile", value };
+}
+
 const MISSION_SCOPE_FILTER_STOPWORDS = new Set([
 	"a",
 	"an",
@@ -654,11 +805,14 @@ function isSessionScopeItemMissionRelevant(item: string, mission: string): boole
 const CONTEXT_PROPOSAL_ANALYST_SYSTEM_PROMPT = [
 	"You analyze recent /cook startup discussion and return a strict JSON object.",
 	"Do not emit markdown, code fences, or commentary.",
-	"Return exactly one JSON object with keys: mission, scope, constraints, acceptance, confidence, possible_noise.",
+	"Return exactly one JSON object with keys: mission, scope, constraints, acceptance, critique, risks, task_type, evaluation_profile, confidence, possible_noise.",
 	"mission must be a concise implementation mission anchor sentence.",
 	"scope must contain only work items that directly support the mission.",
 	"constraints must contain guardrails or non-goals explicitly stated or strongly implied by the discussion.",
 	"acceptance must contain verifiable outcomes explicitly stated or strongly implied by the discussion.",
+	"critique must contain operator-facing cautions, concerns, or reminders that should be shown separately from mission and scope later.",
+	"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.",
@@ -739,12 +893,27 @@ 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 goalText = buildContextProposalGoalText({ mission, scope, constraints, acceptance });
 	return {
 		mission,
 		scope,
 		constraints,
 		acceptance,
+		analysis,
 		goalText,
 		basisPreview: raw.replace(/\s+/g, " ").trim(),
 		source: "analyst",
@@ -963,6 +1132,59 @@ function buildContextProposalDisplayText(proposal: ContextProposal): string {
 	return lines.join("\n");
 }
 
+function finalizeContextProposalAnalysis(analysis: ContextProposalAnalysis | undefined, hintTexts: string[] = []): ContextProposalAnalysis {
+	const merged = mergeContextProposalAnalysis(analysis ? [analysis] : [], hintTexts);
+	return {
+		taskType: merged.taskType ?? DEFAULT_TASK_TYPE,
+		evaluationProfile: merged.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE,
+		critique: merged.critique,
+		risks: merged.risks,
+		possibleNoise: merged.possibleNoise,
+	};
+}
+
+function buildContextProposalCritiqueText(analysis: ContextProposalAnalysis): string {
+	const lines: string[] = [];
+	if (analysis.critique.length > 0) {
+		lines.push("Critique");
+		for (const item of analysis.critique) lines.push(`- ${item}`);
+	}
+	if (analysis.risks.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Risks");
+		for (const item of analysis.risks) lines.push(`- ${item}`);
+	}
+	if (analysis.possibleNoise.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Possible noise");
+		for (const item of analysis.possibleNoise) lines.push(`- ${item}`);
+	}
+	if (lines.length === 0) {
+		return "No critique, risk, or possible-noise notes were derived for this startup proposal.";
+	}
+	return lines.join("\n");
+}
+
+function buildContextProposalRoutingText(analysis: ContextProposalAnalysis): string {
+	return [`- task_type: ${analysis.taskType ?? DEFAULT_TASK_TYPE}`, `- evaluation_profile: ${analysis.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE}`].join(
+		"\n",
+	);
+}
+
+function summarizeContextProposalAnalysisItems(label: string, items: string[]): string | undefined {
+	if (items.length === 0) return undefined;
+	return `${label}=${truncateInline(items.join(" | "), 160)}`;
+}
+
+function buildContextProposalContinuationReason(prefix: string, goalText: string, analysis: ContextProposalAnalysis): string {
+	const critiqueParts = [
+		analysis.critique.length > 0 ? `accepted critique=${truncateInline(analysis.critique.join(" | "), 160)}` : "accepted critique=none",
+		summarizeContextProposalAnalysisItems("risks", analysis.risks),
+		summarizeContextProposalAnalysisItems("possible_noise", analysis.possibleNoise),
+	].filter((part): part is string => Boolean(part));
+	return `${prefix} ${truncateInline(goalText, 220)} | startup routing: task_type=${analysis.taskType ?? DEFAULT_TASK_TYPE}; evaluation_profile=${analysis.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE}; critique outcome=${critiqueParts.join("; ")}`;
+}
+
 function buildContextProposalConfirmationActions(): ContextProposalConfirmationActionItem[] {
 	return [
 		{
@@ -987,11 +1209,16 @@ function buildContextProposalConfirmationLayout(
 	title: string,
 	proposal: ContextProposal,
 ): ContextProposalConfirmationLayout {
+	const analysis = finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]);
 	return {
 		title,
-		intro: "Review the proposed mission, scope, constraints, and acceptance details before /cook writes canonical workflow state.",
+		intro: "Review the proposed mission, scope, constraints, acceptance, critique, and routing details before /cook writes canonical workflow state.",
 		proposalHeading: "Proposed workflow",
 		proposalBody: buildContextProposalDisplayText(proposal),
+		critiqueHeading: "Critique and risks",
+		critiqueBody: buildContextProposalCritiqueText(analysis),
+		routingHeading: "Routing recommendations",
+		routingBody: buildContextProposalRoutingText(analysis),
 		actionsHeading: "Actions",
 		actions: buildContextProposalConfirmationActions(),
 		footer: "↑↓ navigate • enter select • esc cancel",
@@ -1009,6 +1236,17 @@ function maybeWriteContextProposalConfirmationSnapshot(layout: ContextProposalCo
 	}
 }
 
+function maybeWriteContextProposalSnapshot(proposal: ContextProposal): void {
+	const snapshotPath = completionTestContextProposalSnapshotPath();
+	if (!snapshotPath) return;
+	try {
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		fs.writeFileSync(snapshotPath, `${JSON.stringify(proposal, null, 2)}\n`, "utf8");
+	} catch {
+		// ignore malformed or unwritable test snapshot paths
+	}
+}
+
 function buildContextProposalConfirmationSelectItems(layout: ContextProposalConfirmationLayout): SelectItem[] {
 	return layout.actions.map((action) => ({
 		value: action.id,
@@ -1030,6 +1268,16 @@ async function promptContextProposalConfirmationAction(
 		container.addChild(new Text("", 0, 0));
 		container.addChild(new Text(theme.fg("accent", theme.bold(layout.proposalHeading)), 1, 0));
 		container.addChild(new Text(layout.proposalBody, 1, 0));
+		if (layout.critiqueHeading && layout.critiqueBody) {
+			container.addChild(new Text("", 0, 0));
+			container.addChild(new Text(theme.fg("accent", theme.bold(layout.critiqueHeading)), 1, 0));
+			container.addChild(new Text(layout.critiqueBody, 1, 0));
+		}
+		if (layout.routingHeading && layout.routingBody) {
+			container.addChild(new Text("", 0, 0));
+			container.addChild(new Text(theme.fg("accent", theme.bold(layout.routingHeading)), 1, 0));
+			container.addChild(new Text(layout.routingBody, 1, 0));
+		}
 		container.addChild(new Text("", 0, 0));
 		container.addChild(new Text(theme.fg("accent", theme.bold(layout.actionsHeading)), 1, 0));
 		const selectList = new SelectList(items, items.length, {
@@ -1065,17 +1313,28 @@ async function resolveEditedContextProposalDecision(
 	projectName: string,
 	editedText: string,
 	confirmMissionWhenNeeded: boolean,
+	fallbackAnalysis?: ContextProposalAnalysis,
 ): Promise<ContextProposalDecision | undefined> {
 	if (!editedText.trim()) return undefined;
 	const editedProposal = parseContextProposal(editedText, projectName);
-	if (editedProposal) return { missionAnchor: editedProposal.mission, goalText: editedProposal.goalText };
+	if (editedProposal) {
+		return {
+			missionAnchor: editedProposal.mission,
+			goalText: editedProposal.goalText,
+			analysis: finalizeContextProposalAnalysis(
+				mergeContextProposalAnalysis([editedProposal.analysis, fallbackAnalysis], [editedText, editedProposal.mission]),
+				[editedText, editedProposal.mission],
+			),
+		};
+	}
 	const assessment = assessMissionAnchor(editedText, projectName);
+	const analysis = finalizeContextProposalAnalysis(fallbackAnalysis, [editedText, assessment.derived]);
 	if (!confirmMissionWhenNeeded) {
-		return { missionAnchor: assessment.derived, goalText: editedText.trim() };
+		return { missionAnchor: assessment.derived, goalText: editedText.trim(), analysis };
 	}
 	const missionAnchor = await confirmMissionAnchor(ctx, assessment);
 	if (!missionAnchor) return undefined;
-	return { missionAnchor, goalText: editedText.trim() };
+	return { missionAnchor, goalText: editedText.trim(), analysis };
 }
 
 async function resolveContextProposalConfirmationAction(
@@ -1087,8 +1346,9 @@ async function resolveContextProposalConfirmationAction(
 	editedTextOverride?: string,
 ): Promise<ContextProposalDecision | undefined> {
 	if (action === "cancel") return undefined;
+	const analysis = finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]);
 	if (action === "start") {
-		return { missionAnchor: proposal.mission, goalText: proposal.goalText };
+		return { missionAnchor: proposal.mission, goalText: proposal.goalText, analysis };
 	}
 	const editedText =
 		editedTextOverride ??
@@ -1097,7 +1357,7 @@ async function resolveContextProposalConfirmationAction(
 			buildContextProposalEditorText(proposal),
 		));
 	if (!editedText?.trim()) return undefined;
-	return await resolveEditedContextProposalDecision(ctx, projectName, editedText, editedTextOverride === undefined);
+	return await resolveEditedContextProposalDecision(ctx, projectName, editedText, editedTextOverride === undefined, analysis);
 }
 
 function buildContextProposalEditorText(proposal: ContextProposal): string {
@@ -1113,14 +1373,25 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 		.filter((line) => line.length > 0);
 	if (lines.length === 0) return undefined;
 
-	let section: "mission" | "scope" | "constraints" | "acceptance" | undefined;
+	let section: ContextProposalSection | undefined;
 	let missionLine: string | undefined;
+	let taskTypeHint: string | undefined;
+	let evaluationProfileHint: string | undefined;
 	const scope: string[] = [];
 	const constraints: string[] = [];
 	const acceptance: string[] = [];
+	const critique: string[] = [];
+	const risks: string[] = [];
 	let structuredSignalCount = 0;
 
 	for (const rawLine of lines) {
+		const routingHint = matchContextProposalRoutingHint(rawLine);
+		if (routingHint) {
+			structuredSignalCount += 1;
+			if (routingHint.field === "taskType") taskTypeHint = routingHint.value;
+			else evaluationProfileHint = routingHint.value;
+			continue;
+		}
 		const inlineSection = matchInlineProposalSection(rawLine);
 		if (inlineSection) {
 			section = inlineSection.section;
@@ -1133,6 +1404,10 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 				acceptance.push(inlineSection.content);
 			} else if (inlineSection.section === "scope") {
 				scope.push(inlineSection.content);
+			} else if (inlineSection.section === "critique") {
+				critique.push(inlineSection.content);
+			} else if (inlineSection.section === "risks") {
+				risks.push(inlineSection.content);
 			}
 			continue;
 		}
@@ -1161,6 +1436,14 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 				scope.push(bullet);
 				continue;
 			}
+			if (section === "critique") {
+				critique.push(bullet);
+				continue;
+			}
+			if (section === "risks") {
+				risks.push(bullet);
+				continue;
+			}
 			if (!missionLine) {
 				missionLine = bullet;
 				continue;
@@ -1176,6 +1459,14 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 			missionLine = normalized;
 			continue;
 		}
+		if (section === "critique") {
+			critique.push(normalized);
+			continue;
+		}
+		if (section === "risks") {
+			risks.push(normalized);
+			continue;
+		}
 		if (section === "constraints" || looksLikeConstraint(normalized)) {
 			constraints.push(normalized);
 			continue;
@@ -1193,17 +1484,25 @@ function parseContextProposal(text: string, projectName: string): ContextProposa
 	const missionSource = missionLine ?? scope[0] ?? acceptance[0] ?? constraints[0] ?? basisPreview;
 	const assessment = assessMissionAnchor(missionSource, projectName);
 	const normalizedMission = normalizeMissionAnchorText(missionSource);
-	const itemCount = scope.length + constraints.length + acceptance.length;
+	const itemCount = scope.length + constraints.length + acceptance.length + critique.length + risks.length;
 	const hasStrongStructure = structuredSignalCount >= 2 || itemCount >= 2;
 	if (!normalizedMission || isWeakMissionAnchor(normalizedMission)) return undefined;
 	if (!hasStrongStructure && basisPreview.length < 140) return undefined;
 	const mission = assessment.derived;
+	const analysis = buildContextProposalAnalysis({
+		taskType: taskTypeHint,
+		evaluationProfile: evaluationProfileHint,
+		critique,
+		risks,
+		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",
@@ -1234,15 +1533,20 @@ async function buildGoalAnchoredContextProposal(
 	const scope = uniqueProposalItems([...explicitScope, ...sessionScope]);
 	const constraints = uniqueProposalItems([...(explicit?.constraints ?? []), ...(sessionProposal?.constraints ?? [])]);
 	const acceptance = uniqueProposalItems([...(explicit?.acceptance ?? []), ...(sessionProposal?.acceptance ?? [])]);
+	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 ?? "session",
+		source: sessionProposal?.source ?? explicit?.source ?? "session",
 	};
 }
 
@@ -1252,15 +1556,26 @@ async function confirmContextProposal(
 	projectName: string,
 	options: ContextProposalConfirmOptions,
 ): Promise<ContextProposalDecision | undefined> {
+	maybeWriteContextProposalSnapshot(proposal);
 	const actionOverride = completionTestContextProposalActionOverride();
 	if (actionOverride === "cancel") return undefined;
 	if (actionOverride === "accept") {
-		return { missionAnchor: proposal.mission, goalText: proposal.goalText };
+		return {
+			missionAnchor: proposal.mission,
+			goalText: proposal.goalText,
+			analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
+		};
 	}
 	if (actionOverride === "edit") {
 		const editedText = completionTestContextProposalEditText();
 		if (!editedText) return undefined;
-		return await resolveEditedContextProposalDecision(ctx, projectName, editedText, false);
+		return await resolveEditedContextProposalDecision(
+			ctx,
+			projectName,
+			editedText,
+			false,
+			finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
+		);
 	}
 	const layout = buildContextProposalConfirmationLayout(options.title, proposal);
 	maybeWriteContextProposalConfirmationSnapshot(layout);
@@ -1277,13 +1592,21 @@ async function confirmContextProposal(
 	}
 	if (!getCtxHasUI(ctx)) {
 		return options.nonInteractiveBehavior === "accept"
-			? { missionAnchor: proposal.mission, goalText: proposal.goalText }
+			? {
+				missionAnchor: proposal.mission,
+				goalText: proposal.goalText,
+				analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
+			}
 			: undefined;
 	}
 	const ui = getCtxUi(ctx);
 	if (!ui) {
 		return options.nonInteractiveBehavior === "accept"
-			? { missionAnchor: proposal.mission, goalText: proposal.goalText }
+			? {
+				missionAnchor: proposal.mission,
+				goalText: proposal.goalText,
+				analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
+			}
 			: undefined;
 	}
 	const choice = await promptContextProposalConfirmationAction(ui, layout);
@@ -1300,6 +1623,80 @@ function currentMissionAnchor(snapshot: CompletionStateSnapshot): string {
 	);
 }
 
+function currentTaskType(snapshot: CompletionStateSnapshot): string | undefined {
+	return (
+		asString(snapshot.active?.task_type) ??
+		asString(snapshot.state?.task_type) ??
+		asString(snapshot.plan?.task_type) ??
+		asString(snapshot.profile?.task_type)
+	);
+}
+
+function currentEvaluationProfile(snapshot: CompletionStateSnapshot): string | undefined {
+	return (
+		asString(snapshot.active?.evaluation_profile) ??
+		asString(snapshot.state?.evaluation_profile) ??
+		asString(snapshot.plan?.evaluation_profile) ??
+		asString(snapshot.profile?.evaluation_profile)
+	);
+}
+
+function isRubricEvaluationRole(role: string | undefined): role is RubricEvaluationRole {
+	return RUBRIC_EVALUATION_ROLES.includes(role as RubricEvaluationRole);
+}
+
+function activeSliceContext(snapshot: CompletionStateSnapshot) {
+	const active = snapshot.active;
+	const activeSlice = snapshot.activeSlice;
+	return {
+		sliceId: asString(active?.slice_id) ?? asString(activeSlice?.slice_id),
+		status: asString(active?.status) ?? asString(activeSlice?.status),
+		goal: asString(active?.goal) ?? asString(activeSlice?.goal),
+		contractIds:
+			asStringArray(active?.contract_ids).length > 0 ? asStringArray(active?.contract_ids) : asStringArray(activeSlice?.contract_ids),
+		acceptance:
+			asStringArray(active?.acceptance_criteria).length > 0
+				? asStringArray(active?.acceptance_criteria)
+				: asStringArray(activeSlice?.acceptance_criteria),
+		implementationSurfaces: asStringArray(active?.implementation_surfaces),
+		verificationCommands: asStringArray(active?.verification_commands),
+		lockedNotes: asStringArray(active?.locked_notes),
+		mustFixFindings: asStringArray(active?.must_fix_findings),
+		remainingBefore: asStringArray(active?.remaining_contract_ids_before),
+		basisCommit: asString(active?.basis_commit),
+		releaseBlockerCountBefore: asNumber(active?.release_blocker_count_before),
+		highValueGapCountBefore: asNumber(active?.high_value_gap_count_before),
+	};
+}
+
+function buildEvaluationRoleContextLines(snapshot: CompletionStateSnapshot, role: RubricEvaluationRole): string[] {
+	const context = activeSliceContext(snapshot);
+	const lines = [
+		`Canonical evaluation handoff for ${role}:`,
+		`- task_type: ${currentTaskType(snapshot) ?? "(missing)"}`,
+		`- evaluation_profile: ${currentEvaluationProfile(snapshot) ?? "(missing)"}`,
+		`- latest_completed_slice: ${asString(snapshot.state?.latest_completed_slice) ?? "(none)"}`,
+		`- active_slice_id: ${context.sliceId ?? "(none)"}`,
+		`- active_slice_status: ${context.status ?? "(unknown)"}`,
+		`- active_slice_goal: ${context.goal ?? "(unknown)"}`,
+		`- contract_ids: ${context.contractIds.length > 0 ? context.contractIds.join(", ") : "(none)"}`,
+		`- acceptance_criteria: ${context.acceptance.length > 0 ? context.acceptance.join(" | ") : "(none)"}`,
+		`- implementation_surfaces: ${context.implementationSurfaces.length > 0 ? context.implementationSurfaces.join(" | ") : "(none)"}`,
+		`- verification_commands: ${context.verificationCommands.length > 0 ? context.verificationCommands.join(" | ") : "(none)"}`,
+		`- locked_notes: ${context.lockedNotes.length > 0 ? context.lockedNotes.join(" | ") : "(none)"}`,
+		`- must_fix_findings: ${context.mustFixFindings.length > 0 ? context.mustFixFindings.join(" | ") : "(none)"}`,
+		`- basis_commit: ${context.basisCommit ?? "(none)"}`,
+		`- remaining_contract_ids_before: ${context.remainingBefore.length > 0 ? context.remainingBefore.join(", ") : "(none)"}`,
+		`- release_blocker_count_before: ${context.releaseBlockerCountBefore ?? "(unknown)"}`,
+		`- high_value_gap_count_before: ${context.highValueGapCountBefore ?? "(unknown)"}`,
+	];
+	return lines;
+}
+
+function buildEvaluationRoleReminderText(snapshot: CompletionStateSnapshot, role: RubricEvaluationRole): string {
+	return buildEvaluationRoleContextLines(snapshot, role).join(" ");
+}
+
 async function confirmExistingWorkflowGoal(
 	ctx: { hasUI: boolean; ui: any },
 	snapshot: CompletionStateSnapshot,
@@ -1351,22 +1748,41 @@ async function confirmExistingWorkflowGoal(
 	return { action: "continue", currentMissionAnchor: currentMission };
 }
 
-async function refocusCompletionMission(snapshot: CompletionStateSnapshot, missionAnchor: string, rawGoal: string): Promise<void> {
+async function refocusCompletionMission(
+	snapshot: CompletionStateSnapshot,
+	missionAnchor: string,
+	rawGoal: string,
+	analysis?: ContextProposalAnalysis,
+): Promise<void> {
 	const requiredStopJudges = asNumber(snapshot.profile?.required_stop_judges) ?? 3;
 	const root = snapshot.files.root;
+	const routing = finalizeContextProposalAnalysis(analysis, [rawGoal, missionAnchor]);
+	const docsSurfaces = asStringArray(snapshot.profile?.docs_surfaces);
+	const nextProfile = buildProfileRecord({
+		projectName: asString(snapshot.profile?.project_name) ?? path.basename(root),
+		requiredStopJudges,
+		priorityPolicyId: asString(snapshot.profile?.priority_policy_id) ?? "completion-default",
+		docsSurfaces: docsSurfaces.length > 0 ? docsSurfaces : await detectDocsSurfaces(root),
+		taskType: routing.taskType,
+		evaluationProfile: routing.evaluationProfile,
+	});
 	const nextState = {
-		...defaultState(missionAnchor),
+		...defaultState(missionAnchor, {
+			taskType: routing.taskType,
+			evaluationProfile: routing.evaluationProfile,
+			continuationReason: buildContextProposalContinuationReason("User refocused workflow via /cook:", rawGoal, routing),
+		}),
 		remaining_stop_judges: requiredStopJudges,
-		continuation_reason: `User refocused workflow via /cook: ${truncateInline(rawGoal, 160)}`,
 		next_mandatory_action: "Reconcile canonical state from current repo truth for the refocused mission",
 	};
 	const nextPlan = {
-		...defaultPlan(missionAnchor),
+		...defaultPlan(missionAnchor, { taskType: routing.taskType, evaluationProfile: routing.evaluationProfile }),
 		plan_basis: "user_refocus",
 	};
-	const nextActive = defaultActiveSlice(missionAnchor);
+	const nextActive = defaultActiveSlice(missionAnchor, { taskType: routing.taskType, evaluationProfile: routing.evaluationProfile });
 	await Promise.all([
 		fsp.writeFile(path.join(snapshot.files.agentDir, "mission.md"), buildMission(path.basename(root), missionAnchor), "utf8"),
+		writeJsonFile(snapshot.files.profilePath, nextProfile),
 		writeJsonFile(snapshot.files.statePath, nextState),
 		writeJsonFile(snapshot.files.planPath, nextPlan),
 		writeJsonFile(snapshot.files.activePath, nextActive),
@@ -1398,14 +1814,39 @@ function deriveMissionAnchor(rawGoal: string, projectName: string): string {
 	return mission;
 }
 
-function defaultState(missionAnchor: string): JsonRecord {
+function buildProfileRecord(args: {
+	projectName: string;
+	requiredStopJudges: number;
+	priorityPolicyId?: string;
+	docsSurfaces: string[];
+	taskType?: string;
+	evaluationProfile?: string;
+}): JsonRecord {
+	return {
+		schema_version: 1,
+		protocol_id: PROTOCOL_ID,
+		project_name: args.projectName,
+		required_stop_judges: args.requiredStopJudges,
+		priority_policy_id: args.priorityPolicyId ?? "completion-default",
+		task_type: args.taskType ?? DEFAULT_TASK_TYPE,
+		evaluation_profile: args.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE,
+		docs_surfaces: args.docsSurfaces,
+	};
+}
+
+function defaultState(
+	missionAnchor: string,
+	routing?: { taskType?: string; evaluationProfile?: string; continuationReason?: string },
+): JsonRecord {
 	return {
 		schema_version: 1,
 		mission_anchor: missionAnchor,
 		current_phase: "reground",
 		continuation_policy: "continue",
-		continuation_reason: "Fresh completion bootstrap requires canonical re-ground",
+		continuation_reason: routing?.continuationReason ?? "Fresh completion bootstrap requires canonical re-ground",
 		project_done: false,
+		task_type: routing?.taskType ?? DEFAULT_TASK_TYPE,
+		evaluation_profile: routing?.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE,
 		requires_reground: true,
 		slices_since_last_reground: 0,
 		remaining_release_blockers: null,
@@ -1423,20 +1864,30 @@ function defaultState(missionAnchor: string): JsonRecord {
 	};
 }
 
-function defaultPlan(missionAnchor: string): JsonRecord {
+function defaultPlan(
+	missionAnchor: string,
+	routing?: { taskType?: string; evaluationProfile?: string },
+): JsonRecord {
 	return {
 		schema_version: 1,
 		mission_anchor: missionAnchor,
+		task_type: routing?.taskType ?? DEFAULT_TASK_TYPE,
+		evaluation_profile: routing?.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE,
 		last_reground_at: null,
 		plan_basis: "bootstrap",
 		candidate_slices: [],
 	};
 }
 
-function defaultActiveSlice(missionAnchor: string): JsonRecord {
+function defaultActiveSlice(
+	missionAnchor: string,
+	routing?: { taskType?: string; evaluationProfile?: string },
+): JsonRecord {
 	return {
 		schema_version: 1,
 		mission_anchor: missionAnchor,
+		task_type: routing?.taskType ?? DEFAULT_TASK_TYPE,
+		evaluation_profile: routing?.evaluationProfile ?? DEFAULT_EVALUATION_PROFILE,
 		status: "idle",
 		slice_id: null,
 		goal: null,
@@ -1447,6 +1898,8 @@ function defaultActiveSlice(missionAnchor: string): JsonRecord {
 		blocked_on: [],
 		locked_notes: [],
 		must_fix_findings: [],
+		implementation_surfaces: [],
+		verification_commands: [],
 		basis_commit: null,
 		remaining_contract_ids_before: [],
 		release_blocker_count_before: null,
@@ -1470,15 +1923,151 @@ function buildVerifyStopScript(verifierCommand?: string): string {
 }
 
 function buildVerifyControlPlaneScript(): string {
-	return `#!/usr/bin/env bash\nset -euo pipefail\n\nfor file in \\
-  .agent/README.md \\
-  .agent/mission.md \\
-  .agent/profile.json \\
-  .agent/verify_completion_stop.sh \\
-  .agent/verify_completion_control_plane.sh \\
-  .agent/state.json \\
-  .agent/plan.json \\
-  .agent/active-slice.json; do\n  [[ -e "$file" ]] || { echo "missing required file: $file"; exit 1; }\ndone\n\nnode <<'NODE'\nconst fs = require('node:fs');\n\nconst readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));\nconst assert = (condition, message) => {\n  if (!condition) {\n    console.error(message);\n    process.exit(1);\n  }\n};\nconst isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);\nconst isString = (value) => typeof value === 'string';\nconst isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string');\nconst hasOnlyKeys = (object, allowed, label) => {\n  const unknown = Object.keys(object).filter((key) => !allowed.includes(key));\n  assert(unknown.length === 0, label + ': unknown keys: ' + unknown.join(', '));\n};\nconst requireKeys = (object, required, label) => {\n  for (const key of required) {\n    assert(Object.prototype.hasOwnProperty.call(object, key), label + ': missing required field: ' + key);\n  }\n};\n\nfor (const file of ['.agent/profile.json', '.agent/state.json', '.agent/plan.json', '.agent/active-slice.json']) {\n  readJson(file);\n}\n\nconst profile = readJson('.agent/profile.json');\nconst state = readJson('.agent/state.json');\nconst plan = readJson('.agent/plan.json');\nconst active = readJson('.agent/active-slice.json');\n\nassert(isObject(profile), '.agent/profile.json must be an object');\nassert(isObject(state), '.agent/state.json must be an object');\nassert(isObject(plan), '.agent/plan.json must be an object');\nassert(isObject(active), '.agent/active-slice.json must be an object');\n\nconst requiredProfile = ['schema_version', 'protocol_id', 'project_name', 'required_stop_judges', 'priority_policy_id', 'docs_surfaces'];\nrequireKeys(profile, requiredProfile, '.agent/profile.json');\nhasOnlyKeys(profile, requiredProfile, '.agent/profile.json');\nassert(profile.protocol_id === 'completion', '.agent/profile.json: protocol_id must be completion');\nassert(Array.isArray(profile.docs_surfaces), '.agent/profile.json: docs_surfaces must be an array');\n\nconst requiredState = [\n  'schema_version','mission_anchor','current_phase','continuation_policy','continuation_reason','project_done',\n  'requires_reground','slices_since_last_reground','remaining_release_blockers','remaining_high_value_gaps',\n  'unsatisfied_contract_ids','release_blocker_ids','next_mandatory_action','next_mandatory_role',\n  'remaining_stop_judges','last_reground_at','last_auditor_verdict','contract_status','latest_completed_slice','latest_verified_slice'\n];\nconst continuationPolicies = ['continue', 'await_user_input', 'blocked', 'paused', 'done'];\nconst workflowRoles = ['completion-bootstrapper', 'completion-regrounder', 'completion-implementer', 'completion-reviewer', 'completion-auditor', 'completion-stop-judge', null];\nconst workflowPhases = ['reground', 'implement', 'post_commit_review', 'post_commit_audit', 'post_commit_reconcile', 'stop_wave', 'awaiting_user', 'blocked', 'done'];\nrequireKeys(state, requiredState, '.agent/state.json');\nhasOnlyKeys(state, requiredState, '.agent/state.json');\nassert(continuationPolicies.includes(state.continuation_policy), '.agent/state.json: invalid continuation_policy');\nassert(workflowRoles.includes(state.next_mandatory_role), '.agent/state.json: invalid next_mandatory_role');\nassert(workflowPhases.includes(state.current_phase), '.agent/state.json: invalid current_phase');\nassert(isStringArray(state.unsatisfied_contract_ids), '.agent/state.json: unsatisfied_contract_ids must be an array of strings');\nassert(isStringArray(state.release_blocker_ids), '.agent/state.json: release_blocker_ids must be an array of strings');\n\nconst requiredPlan = ['schema_version', 'mission_anchor', 'last_reground_at', 'plan_basis', 'candidate_slices'];\nconst requiredSlice = ['slice_id', 'goal', 'acceptance_criteria', 'contract_ids', 'priority', 'status', 'why_now', 'blocked_on', 'evidence'];\nconst sliceStatuses = ['planned', 'selected', 'in_progress', 'blocked', 'done', 'cancelled'];\nrequireKeys(plan, requiredPlan, '.agent/plan.json');\nhasOnlyKeys(plan, requiredPlan, '.agent/plan.json');\nassert(Array.isArray(plan.candidate_slices), '.agent/plan.json: candidate_slices must be an array');\nfor (const [index, slice] of plan.candidate_slices.entries()) {\n  const label = '.agent/plan.json candidate_slices[' + index + ']';\n  assert(isObject(slice), label + ' must be an object');\n  requireKeys(slice, requiredSlice, label);\n  hasOnlyKeys(slice, requiredSlice, label);\n  assert(isString(slice.slice_id) && slice.slice_id.length > 0, label + ': slice_id must be a non-empty string');\n  assert(isString(slice.goal) && slice.goal.length > 0, label + ': goal must be a non-empty string');\n  assert(Array.isArray(slice.acceptance_criteria) && slice.acceptance_criteria.length > 0 && slice.acceptance_criteria.every((item) => typeof item === 'string' && item.length > 0), label + ': acceptance_criteria must be a non-empty array of strings');\n  assert(isStringArray(slice.contract_ids), label + ': contract_ids must be an array of strings');\n  assert(typeof slice.priority === 'number' && Number.isFinite(slice.priority), label + ': priority must be a finite number');\n  assert(sliceStatuses.includes(slice.status), label + ': invalid status');\n  assert(isString(slice.why_now) && slice.why_now.length > 0, label + ': why_now must be a non-empty string');\n  assert(isStringArray(slice.blocked_on), label + ': blocked_on must be an array of strings');\n  assert(isStringArray(slice.evidence), label + ': evidence must be an array of strings');\n}\n\nconst requiredActiveBase = ['schema_version', 'mission_anchor', 'status', 'slice_id', 'goal', 'contract_ids', 'acceptance_criteria', 'blocked_on', 'locked_notes', 'must_fix_findings', 'basis_commit', 'remaining_contract_ids_before', 'release_blocker_count_before', 'high_value_gap_count_before'];\nconst allowedActive = [...requiredActiveBase, 'priority', 'why_now'];\nconst activeStatuses = ['idle', 'selected', 'in_progress', 'committed', 'done'];\nrequireKeys(active, requiredActiveBase, '.agent/active-slice.json');\nhasOnlyKeys(active, allowedActive, '.agent/active-slice.json');\nassert(activeStatuses.includes(active.status), '.agent/active-slice.json: invalid status');\nassert(isStringArray(active.contract_ids), '.agent/active-slice.json: contract_ids must be an array of strings');\nassert(Array.isArray(active.acceptance_criteria), '.agent/active-slice.json: acceptance_criteria must be an array');\nassert(isStringArray(active.blocked_on), '.agent/active-slice.json: blocked_on must be an array of strings');\nassert(isStringArray(active.locked_notes), '.agent/active-slice.json: locked_notes must be an array of strings');\nassert(isStringArray(active.must_fix_findings), '.agent/active-slice.json: must_fix_findings must be an array of strings');\nassert(isStringArray(active.remaining_contract_ids_before), '.agent/active-slice.json: remaining_contract_ids_before must be an array of strings');\n\nconst requiresExactHandoff = ['selected', 'in_progress', 'committed', 'done'].includes(active.status);\nif (requiresExactHandoff) {\n  assert(Array.isArray(active.acceptance_criteria) && active.acceptance_criteria.length > 0 && active.acceptance_criteria.every((item) => typeof item === 'string' && item.length > 0), '.agent/active-slice.json: acceptance_criteria must be a non-empty array of strings when status carries an exact handoff');\n  assert(typeof active.priority === 'number' && Number.isFinite(active.priority), '.agent/active-slice.json: priority must be a finite number when status carries an exact handoff');\n  assert(isString(active.why_now) && active.why_now.length > 0, '.agent/active-slice.json: why_now must be a non-empty string when status carries an exact handoff');\n  assert(isString(active.basis_commit) && active.basis_commit.length > 0, '.agent/active-slice.json: basis_commit must be a non-empty string when status carries an exact handoff');\n  assert(typeof active.release_blocker_count_before === 'number' && Number.isFinite(active.release_blocker_count_before), '.agent/active-slice.json: release_blocker_count_before must be a finite number when status carries an exact handoff');\n  assert(typeof active.high_value_gap_count_before === 'number' && Number.isFinite(active.high_value_gap_count_before), '.agent/active-slice.json: high_value_gap_count_before must be a finite number when status carries an exact handoff');\n} else {\n  assert(active.priority === null || active.priority === undefined || (typeof active.priority === 'number' && Number.isFinite(active.priority)), '.agent/active-slice.json: idle priority must be null/undefined or a finite number');\n  assert(active.why_now === null || active.why_now === undefined || typeof active.why_now === 'string', '.agent/active-slice.json: idle why_now must be null/undefined or a string');\n}\nNODE\n`;
+	return `#!/usr/bin/env bash
+set -euo pipefail
+
+for file in \
+  .agent/README.md \
+  .agent/mission.md \
+  .agent/profile.json \
+  .agent/verify_completion_stop.sh \
+  .agent/verify_completion_control_plane.sh \
+  .agent/state.json \
+  .agent/plan.json \
+  .agent/active-slice.json; do
+  [[ -e "$file" ]] || { echo "missing required file: $file"; exit 1; }
+done
+
+node <<'NODE'
+const fs = require('node:fs');
+
+const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
+const assert = (condition, message) => {
+  if (!condition) {
+    console.error(message);
+    process.exit(1);
+  }
+};
+const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isString = (value) => typeof value === 'string';
+const isNonEmptyString = (value) => isString(value) && value.length > 0;
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string');
+const hasOnlyKeys = (object, allowed, label) => {
+  const unknown = Object.keys(object).filter((key) => !allowed.includes(key));
+  assert(unknown.length === 0, label + ': unknown keys: ' + unknown.join(', '));
+};
+const requireKeys = (object, required, label) => {
+  for (const key of required) {
+    assert(Object.prototype.hasOwnProperty.call(object, key), label + ': missing required field: ' + key);
+  }
+};
+
+for (const file of ['.agent/profile.json', '.agent/state.json', '.agent/plan.json', '.agent/active-slice.json']) {
+  readJson(file);
+}
+
+const profile = readJson('.agent/profile.json');
+const state = readJson('.agent/state.json');
+const plan = readJson('.agent/plan.json');
+const active = readJson('.agent/active-slice.json');
+
+assert(isObject(profile), '.agent/profile.json must be an object');
+assert(isObject(state), '.agent/state.json must be an object');
+assert(isObject(plan), '.agent/plan.json must be an object');
+assert(isObject(active), '.agent/active-slice.json must be an object');
+
+const requiredProfile = ['schema_version', 'protocol_id', 'project_name', 'required_stop_judges', 'priority_policy_id', 'task_type', 'evaluation_profile', 'docs_surfaces'];
+requireKeys(profile, requiredProfile, '.agent/profile.json');
+hasOnlyKeys(profile, requiredProfile, '.agent/profile.json');
+assert(profile.protocol_id === 'completion', '.agent/profile.json: protocol_id must be completion');
+assert(Array.isArray(profile.docs_surfaces), '.agent/profile.json: docs_surfaces must be an array');
+assert(isNonEmptyString(profile.task_type), '.agent/profile.json: task_type must be a non-empty string');
+assert(isNonEmptyString(profile.evaluation_profile), '.agent/profile.json: evaluation_profile must be a non-empty string');
+
+const requiredState = [
+  'schema_version','mission_anchor','task_type','evaluation_profile','current_phase','continuation_policy','continuation_reason','project_done',
+  'requires_reground','slices_since_last_reground','remaining_release_blockers','remaining_high_value_gaps',
+  'unsatisfied_contract_ids','release_blocker_ids','next_mandatory_action','next_mandatory_role',
+  'remaining_stop_judges','last_reground_at','last_auditor_verdict','contract_status','latest_completed_slice','latest_verified_slice'
+];
+const continuationPolicies = ['continue', 'await_user_input', 'blocked', 'paused', 'done'];
+const workflowRoles = ['completion-bootstrapper', 'completion-regrounder', 'completion-implementer', 'completion-reviewer', 'completion-auditor', 'completion-stop-judge', null];
+const workflowPhases = ['reground', 'implement', 'post_commit_review', 'post_commit_audit', 'post_commit_reconcile', 'stop_wave', 'awaiting_user', 'blocked', 'done'];
+requireKeys(state, requiredState, '.agent/state.json');
+hasOnlyKeys(state, requiredState, '.agent/state.json');
+assert(continuationPolicies.includes(state.continuation_policy), '.agent/state.json: invalid continuation_policy');
+assert(workflowRoles.includes(state.next_mandatory_role), '.agent/state.json: invalid next_mandatory_role');
+assert(workflowPhases.includes(state.current_phase), '.agent/state.json: invalid current_phase');
+assert(isNonEmptyString(state.task_type), '.agent/state.json: task_type must be a non-empty string');
+assert(isNonEmptyString(state.evaluation_profile), '.agent/state.json: evaluation_profile must be a non-empty string');
+assert(isStringArray(state.unsatisfied_contract_ids), '.agent/state.json: unsatisfied_contract_ids must be an array of strings');
+assert(isStringArray(state.release_blocker_ids), '.agent/state.json: release_blocker_ids must be an array of strings');
+
+const requiredPlan = ['schema_version', 'mission_anchor', 'task_type', 'evaluation_profile', 'last_reground_at', 'plan_basis', 'candidate_slices'];
+const requiredSlice = ['slice_id', 'goal', 'acceptance_criteria', 'contract_ids', 'priority', 'status', 'why_now', 'blocked_on', 'evidence'];
+const sliceStatuses = ['planned', 'selected', 'in_progress', 'blocked', 'done', 'cancelled'];
+requireKeys(plan, requiredPlan, '.agent/plan.json');
+hasOnlyKeys(plan, requiredPlan, '.agent/plan.json');
+assert(isNonEmptyString(plan.task_type), '.agent/plan.json: task_type must be a non-empty string');
+assert(isNonEmptyString(plan.evaluation_profile), '.agent/plan.json: evaluation_profile must be a non-empty string');
+assert(Array.isArray(plan.candidate_slices), '.agent/plan.json: candidate_slices must be an array');
+for (const [index, slice] of plan.candidate_slices.entries()) {
+  const label = '.agent/plan.json candidate_slices[' + index + ']';
+  assert(isObject(slice), label + ' must be an object');
+  requireKeys(slice, requiredSlice, label);
+  hasOnlyKeys(slice, requiredSlice, label);
+  assert(isString(slice.slice_id) && slice.slice_id.length > 0, label + ': slice_id must be a non-empty string');
+  assert(isString(slice.goal) && slice.goal.length > 0, label + ': goal must be a non-empty string');
+  assert(Array.isArray(slice.acceptance_criteria) && slice.acceptance_criteria.length > 0 && slice.acceptance_criteria.every((item) => typeof item === 'string' && item.length > 0), label + ': acceptance_criteria must be a non-empty array of strings');
+  assert(isStringArray(slice.contract_ids), label + ': contract_ids must be an array of strings');
+  assert(typeof slice.priority === 'number' && Number.isFinite(slice.priority), label + ': priority must be a finite number');
+  assert(sliceStatuses.includes(slice.status), label + ': invalid status');
+  assert(isString(slice.why_now) && slice.why_now.length > 0, label + ': why_now must be a non-empty string');
+  assert(isStringArray(slice.blocked_on), label + ': blocked_on must be an array of strings');
+  assert(isStringArray(slice.evidence), label + ': evidence must be an array of strings');
+}
+
+const isNonEmptyStringArray = (value) => Array.isArray(value) && value.length > 0 && value.every((item) => isNonEmptyString(item));
+const requiredActiveBase = ['schema_version', 'mission_anchor', 'task_type', 'evaluation_profile', 'status', 'slice_id', 'goal', 'contract_ids', 'acceptance_criteria', 'blocked_on', 'locked_notes', 'must_fix_findings', 'implementation_surfaces', 'verification_commands', 'basis_commit', 'remaining_contract_ids_before', 'release_blocker_count_before', 'high_value_gap_count_before'];
+const allowedActive = [...requiredActiveBase, 'priority', 'why_now'];
+const activeStatuses = ['idle', 'selected', 'in_progress', 'committed', 'done'];
+requireKeys(active, requiredActiveBase, '.agent/active-slice.json');
+hasOnlyKeys(active, allowedActive, '.agent/active-slice.json');
+assert(activeStatuses.includes(active.status), '.agent/active-slice.json: invalid status');
+assert(isNonEmptyString(active.task_type), '.agent/active-slice.json: task_type must be a non-empty string');
+assert(isNonEmptyString(active.evaluation_profile), '.agent/active-slice.json: evaluation_profile must be a non-empty string');
+assert(isStringArray(active.contract_ids), '.agent/active-slice.json: contract_ids must be an array of strings');
+assert(Array.isArray(active.acceptance_criteria), '.agent/active-slice.json: acceptance_criteria must be an array');
+assert(isStringArray(active.blocked_on), '.agent/active-slice.json: blocked_on must be an array of strings');
+assert(isStringArray(active.locked_notes), '.agent/active-slice.json: locked_notes must be an array of strings');
+assert(isStringArray(active.must_fix_findings), '.agent/active-slice.json: must_fix_findings must be an array of strings');
+assert(isStringArray(active.implementation_surfaces), '.agent/active-slice.json: implementation_surfaces must be an array of strings');
+assert(isStringArray(active.verification_commands), '.agent/active-slice.json: verification_commands must be an array of strings');
+assert(isStringArray(active.remaining_contract_ids_before), '.agent/active-slice.json: remaining_contract_ids_before must be an array of strings');
+
+assert(state.task_type === profile.task_type, '.agent/state.json: task_type must match .agent/profile.json');
+assert(plan.task_type === profile.task_type, '.agent/plan.json: task_type must match .agent/profile.json');
+assert(active.task_type === profile.task_type, '.agent/active-slice.json: task_type must match .agent/profile.json');
+assert(state.evaluation_profile === profile.evaluation_profile, '.agent/state.json: evaluation_profile must match .agent/profile.json');
+assert(plan.evaluation_profile === profile.evaluation_profile, '.agent/plan.json: evaluation_profile must match .agent/profile.json');
+assert(active.evaluation_profile === profile.evaluation_profile, '.agent/active-slice.json: evaluation_profile must match .agent/profile.json');
+
+const requiresExactHandoff = ['selected', 'in_progress', 'committed', 'done'].includes(active.status);
+if (requiresExactHandoff) {
+  assert(isNonEmptyStringArray(active.acceptance_criteria), '.agent/active-slice.json: acceptance_criteria must be a non-empty array of strings when status carries an exact handoff');
+  assert(typeof active.priority === 'number' && Number.isFinite(active.priority), '.agent/active-slice.json: priority must be a finite number when status carries an exact handoff');
+  assert(isString(active.why_now) && active.why_now.length > 0, '.agent/active-slice.json: why_now must be a non-empty string when status carries an exact handoff');
+  assert(isNonEmptyStringArray(active.implementation_surfaces), '.agent/active-slice.json: implementation_surfaces must be a non-empty array of strings when status carries an exact handoff');
+  assert(isNonEmptyStringArray(active.verification_commands), '.agent/active-slice.json: verification_commands must be a non-empty array of strings when status carries an exact handoff');
+  assert(isString(active.basis_commit) && active.basis_commit.length > 0, '.agent/active-slice.json: basis_commit must be a non-empty string when status carries an exact handoff');
+  assert(typeof active.release_blocker_count_before === 'number' && Number.isFinite(active.release_blocker_count_before), '.agent/active-slice.json: release_blocker_count_before must be a finite number when status carries an exact handoff');
+  assert(typeof active.high_value_gap_count_before === 'number' && Number.isFinite(active.high_value_gap_count_before), '.agent/active-slice.json: high_value_gap_count_before must be a finite number when status carries an exact handoff');
+} else {
+  assert(active.priority === null || active.priority === undefined || (typeof active.priority === 'number' && Number.isFinite(active.priority)), '.agent/active-slice.json: idle priority must be null/undefined or a finite number');
+  assert(active.why_now === null || active.why_now === undefined || typeof active.why_now === 'string', '.agent/active-slice.json: idle why_now must be null/undefined or a string');
+}
+NODE
+`;
 }
 
 async function ensureGitignore(root: string): Promise<boolean> {
@@ -1515,13 +2104,18 @@ type ScaffoldResult = {
 	missionAnchor: string;
 };
 
-async function scaffoldCompletionFiles(root: string, missionAnchor: string): Promise<ScaffoldResult> {
+async function scaffoldCompletionFiles(
+	root: string,
+	missionAnchor: string,
+	options?: { analysis?: ContextProposalAnalysis; continuationReason?: string },
+): Promise<ScaffoldResult> {
 	const files = resolveFiles(root);
 	const created: string[] = [];
 	const updated: string[] = [];
 	await fsp.mkdir(files.agentDir, { recursive: true });
 	await fsp.mkdir(path.join(files.agentDir, "tmp"), { recursive: true });
 	const projectName = path.basename(root);
+	const routing = finalizeContextProposalAnalysis(options?.analysis, [missionAnchor]);
 	const docsSurfaces = await detectDocsSurfaces(root);
 	const verifierCommand = await detectVerifierCommand(root);
 	const trackedFiles: Array<{ path: string; content: string; executable?: boolean }> = [
@@ -1529,13 +2123,16 @@ async function scaffoldCompletionFiles(root: string, missionAnchor: string): Pro
 		{ path: path.join(files.agentDir, "mission.md"), content: buildMission(projectName, missionAnchor) },
 		{
 			path: files.profilePath,
-			content: `${JSON.stringify({ schema_version: 1, protocol_id: PROTOCOL_ID, project_name: projectName, required_stop_judges: 3, priority_policy_id: "completion-default", docs_surfaces: docsSurfaces }, null, 2)}\n`,
+			content: `${JSON.stringify(buildProfileRecord({ projectName, requiredStopJudges: 3, docsSurfaces, taskType: routing.taskType, evaluationProfile: routing.evaluationProfile }), null, 2)}\n`,
 		},
 		{ path: path.join(files.agentDir, "verify_completion_stop.sh"), content: buildVerifyStopScript(verifierCommand), executable: true },
 		{ path: path.join(files.agentDir, "verify_completion_control_plane.sh"), content: buildVerifyControlPlaneScript(), executable: true },
-		{ path: files.statePath, content: `${JSON.stringify(defaultState(missionAnchor), null, 2)}\n` },
-		{ path: files.planPath, content: `${JSON.stringify(defaultPlan(missionAnchor), null, 2)}\n` },
-		{ path: files.activePath, content: `${JSON.stringify(defaultActiveSlice(missionAnchor), null, 2)}\n` },
+		{
+			path: files.statePath,
+			content: `${JSON.stringify(defaultState(missionAnchor, { taskType: routing.taskType, evaluationProfile: routing.evaluationProfile, continuationReason: options?.continuationReason }), null, 2)}\n`,
+		},
+		{ path: files.planPath, content: `${JSON.stringify(defaultPlan(missionAnchor, { taskType: routing.taskType, evaluationProfile: routing.evaluationProfile }), null, 2)}\n` },
+		{ path: files.activePath, content: `${JSON.stringify(defaultActiveSlice(missionAnchor, { taskType: routing.taskType, evaluationProfile: routing.evaluationProfile }), null, 2)}\n` },
 		{ path: files.sliceHistoryPath, content: "" },
 		{ path: files.stopHistoryPath, content: "" },
 	];
@@ -1573,8 +2170,12 @@ function activeSliceMatchesPlan(snapshot: CompletionStateSnapshot): "yes" | "no"
 }
 
 function handoffSnapshotState(active: JsonRecord | undefined): "present" | "missing_or_unclear" {
+	const exactArrays = [
+		asStringArray(active?.acceptance_criteria),
+		asStringArray(active?.implementation_surfaces),
+		asStringArray(active?.verification_commands),
+	];
 	const required = [
-		active?.acceptance_criteria,
 		active?.priority,
 		active?.why_now,
 		active?.blocked_on,
@@ -1585,15 +2186,24 @@ function handoffSnapshotState(active: JsonRecord | undefined): "present" | "miss
 		active?.release_blocker_count_before,
 		active?.high_value_gap_count_before,
 	];
-	return required.every((value) => value !== undefined && value !== null) ? "present" : "missing_or_unclear";
+	return exactArrays.every((items) => items.length > 0) && required.every((value) => value !== undefined && value !== null)
+		? "present"
+		: "missing_or_unclear";
 }
 
 function buildSystemReminder(snapshot: CompletionStateSnapshot, sliceHistory: JsonRecord[], stopHistory: JsonRecord[]): string {
 	const history = historyCounts(sliceHistory, stopHistory);
-	return [
+	const implementationSurfaces = asStringArray(snapshot.active?.implementation_surfaces);
+	const verificationCommands = asStringArray(snapshot.active?.verification_commands);
+	const activePriority = asNumber(snapshot.active?.priority);
+	const activeWhyNow = asString(snapshot.active?.why_now);
+	const nextRole = asString(snapshot.state?.next_mandatory_role);
+	const lines = [
 		"Completion workflow detected.",
 		"Canonical truth lives in .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, and .agent/stop-check-history.jsonl.",
 		`Mission anchor: ${asString(snapshot.state?.mission_anchor) ?? "(unknown)"}`,
+		`Task type: ${currentTaskType(snapshot) ?? "(missing)"}`,
+		`Evaluation profile: ${currentEvaluationProfile(snapshot) ?? "(missing)"}`,
 		`Current phase: ${asString(snapshot.state?.current_phase) ?? "unknown"}`,
 		`Continuation policy: ${asString(snapshot.state?.continuation_policy) ?? "unknown"}`,
 		`Continuation reason: ${asString(snapshot.state?.continuation_reason) ?? "(unknown)"}`,
@@ -1607,7 +2217,13 @@ function buildSystemReminder(snapshot: CompletionStateSnapshot, sliceHistory: Js
 		"Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.",
 		"If canonical state is stale, invalid, ambiguous, or missing, route to completion-regrounder.",
 		"When recovering from compaction, prefer a deterministic restart from canonical files over conversational inference.",
-	].join(" ");
+	];
+	if (activePriority !== undefined) lines.push(`Active slice priority: ${activePriority}`);
+	if (activeWhyNow) lines.push(`Active slice why_now: ${activeWhyNow}`);
+	if (implementationSurfaces.length > 0) lines.push(`Active implementation surfaces: ${implementationSurfaces.join(", ")}`);
+	if (verificationCommands.length > 0) lines.push(`Active verification commands: ${verificationCommands.join(" | ")}`);
+	if (isRubricEvaluationRole(nextRole)) lines.push(buildEvaluationRoleReminderText(snapshot, nextRole));
+	return lines.join(" ");
 }
 
 function buildPostCompactionDriverInstructions(snapshot: CompletionStateSnapshot, marker: JsonRecord | undefined): string {
@@ -1616,11 +2232,19 @@ function buildPostCompactionDriverInstructions(snapshot: CompletionStateSnapshot
 	const nextAction = asString(snapshot.state?.next_mandatory_action) ?? "unknown";
 	const continuation = asString(snapshot.state?.continuation_policy) ?? "unknown";
 	const activeSliceId = asString(snapshot.active?.slice_id) ?? asString(snapshot.activeSlice?.slice_id) ?? "(none)";
-	return [
+	const taskType = currentTaskType(snapshot) ?? "(missing)";
+	const evaluationProfile = currentEvaluationProfile(snapshot) ?? "(missing)";
+	const implementationSurfaces = asStringArray(snapshot.active?.implementation_surfaces);
+	const verificationCommands = asStringArray(snapshot.active?.verification_commands);
+	const activePriority = asNumber(snapshot.active?.priority);
+	const activeWhyNow = asString(snapshot.active?.why_now);
+	const lines = [
 		"POST-COMPACTION RECOVERY MODE is active.",
 		`Compaction marker time: ${markerAt}`,
 		"Treat the previous conversation as lossy continuity support only.",
 		"Before taking any substantive action, re-read .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, and .agent/stop-check-history.jsonl from disk.",
+		`Canonical task_type is currently: ${taskType}`,
+		`Canonical evaluation_profile is currently: ${evaluationProfile}`,
 		`Canonical next mandatory role is currently: ${nextRole}`,
 		`Canonical next mandatory action is currently: ${nextAction}`,
 		`Canonical continuation policy is currently: ${continuation}`,
@@ -1629,7 +2253,13 @@ function buildPostCompactionDriverInstructions(snapshot: CompletionStateSnapshot
 		"If the canonical state is ambiguous, inconsistent, missing, or stale after re-reading it, your first mandatory action is to dispatch completion-regrounder rather than guessing.",
 		"If continuation_policy == continue and canonical state is coherent, continue dispatching the mandatory role directly without asking the user whether to continue.",
 		"If you are about to implement after compaction, confirm the active slice snapshot still matches .agent/plan.json before doing any work.",
-	].join(" ");
+	];
+	if (activePriority !== undefined) lines.push(`Canonical active-slice priority is currently: ${activePriority}`);
+	if (activeWhyNow) lines.push(`Canonical active-slice why_now is currently: ${activeWhyNow}`);
+	if (implementationSurfaces.length > 0) lines.push(`Canonical implementation surfaces are currently: ${implementationSurfaces.join(", ")}`);
+	if (verificationCommands.length > 0) lines.push(`Canonical verification commands are currently: ${verificationCommands.join(" | ")}`);
+	if (isRubricEvaluationRole(nextRole)) lines.push(buildEvaluationRoleReminderText(snapshot, nextRole));
+	return lines.join(" ");
 }
 
 function isStaleContextError(error: unknown): boolean {
@@ -1705,12 +2335,16 @@ function buildResumeCapsule(snapshot: CompletionStateSnapshot, sliceHistory: Jso
 		: asStringArray(snapshot.activeSlice?.blocked_on);
 	const lockedNotes = asStringArray(snapshot.active?.locked_notes);
 	const mustFixFindings = asStringArray(snapshot.active?.must_fix_findings);
+	const implementationSurfaces = asStringArray(snapshot.active?.implementation_surfaces);
+	const verificationCommands = asStringArray(snapshot.active?.verification_commands);
 	const remainingBefore = asStringArray(snapshot.active?.remaining_contract_ids_before);
 	const lines = [
 		"Authoritative completion resume capsule:",
 		"",
 		"<completion-state>",
 		`mission_anchor: ${asString(snapshot.state?.mission_anchor) ?? "(unknown)"}`,
+		`task_type: ${currentTaskType(snapshot) ?? "(missing)"}`,
+		`evaluation_profile: ${currentEvaluationProfile(snapshot) ?? "(missing)"}`,
 		`current_phase: ${asString(snapshot.state?.current_phase) ?? "unknown"}`,
 		`continuation_policy: ${asString(snapshot.state?.continuation_policy) ?? "unknown"}`,
 		`continuation_reason: ${asString(snapshot.state?.continuation_reason) ?? "(unknown)"}`,
@@ -1727,11 +2361,15 @@ function buildResumeCapsule(snapshot: CompletionStateSnapshot, sliceHistory: Jso
 		`- slice_id: ${asString(snapshot.active?.slice_id) ?? asString(snapshot.activeSlice?.slice_id) ?? "(none)"}`,
 		`- status: ${asString(snapshot.active?.status) ?? asString(snapshot.activeSlice?.status) ?? "unknown"}`,
 		`- goal: ${asString(snapshot.active?.goal) ?? asString(snapshot.activeSlice?.goal) ?? "(unknown)"}`,
+		`- priority: ${asNumber(snapshot.active?.priority) ?? "(unknown)"}`,
+		`- why_now: ${asString(snapshot.active?.why_now) ?? "(unknown)"}`,
 		`- contract_ids: ${contractIds.length > 0 ? contractIds.join(", ") : "(none)"}`,
 	];
 	if (blockedOn.length > 0) lines.push(`- blocked_on: ${blockedOn.join(", ")}`);
 	if (lockedNotes.length > 0) lines.push(`- locked_notes: ${lockedNotes.join(" | ")}`);
 	if (mustFixFindings.length > 0) lines.push(`- must_fix_findings: ${mustFixFindings.join(" | ")}`);
+	if (implementationSurfaces.length > 0) lines.push(`- implementation_surfaces: ${implementationSurfaces.join(" | ")}`);
+	if (verificationCommands.length > 0) lines.push(`- verification_commands: ${verificationCommands.join(" | ")}`);
 	lines.push(`- basis_commit: ${asString(snapshot.active?.basis_commit) ?? "(none)"}`);
 	lines.push(`- remaining_contract_ids_before: ${remainingBefore.length > 0 ? remainingBefore.join(", ") : "(none)"}`);
 	lines.push(`- release_blocker_count_before: ${asNumber(snapshot.active?.release_blocker_count_before) ?? "(unknown)"}`);
@@ -1743,7 +2381,7 @@ function buildResumeCapsule(snapshot: CompletionStateSnapshot, sliceHistory: Jso
 		"",
 		"Rules:",
 		"- Treat this block as continuity support derived from canonical .agent state.",
-		"- Preserve exact slice_id, contract_ids, acceptance criteria, locked notes, and must-fix findings where still true.",
+		"- Preserve exact slice_id, contract_ids, acceptance criteria, priority, why_now, implementation surfaces, verification commands, locked notes, and must-fix findings where still true.",
 		"- After compaction, re-read .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, and .agent/stop-check-history.jsonl before resuming long-running completion work.",
 		"- Invoke completion-regrounder before continuing when requires_reground is true or unknown.",
 		"- Invoke completion-regrounder before continuing when next_mandatory_role or next_mandatory_action is unknown or ambiguous.",
@@ -2076,33 +2714,15 @@ async function refreshStatus(ctx: { cwd: string; hasUI: boolean; ui: any }) {
 }
 
 function parseReportFields(text: string): Record<string, string> {
-	const fields: Record<string, string> = {};
-	for (const rawLine of text.split("\n")) {
-		const line = rawLine.trim();
-		if (!line) continue;
-		const normalized = line.replace(/^-\s*/, "").replace(/^`/, "").replace(/`$/, "");
-		const match = normalized.match(/^([A-Za-z][A-Za-z0-9 _\/-]*?):\s*(.*)$/);
-		if (!match) continue;
-		const [, key, value] = match;
-		fields[key.trim()] = value.trim();
-	}
-	return fields;
+	return roleReporting.parseReportFields(text);
 }
 
 function parseYesNo(value: string | undefined): boolean | undefined {
-	if (!value) return undefined;
-	const normalized = value.trim().toLowerCase();
-	if (normalized.startsWith("yes")) return true;
-	if (normalized.startsWith("no")) return false;
-	return undefined;
+	return roleReporting.parseYesNo(value);
 }
 
 function parseFirstNumber(value: string | undefined): number | undefined {
-	if (!value) return undefined;
-	const match = value.match(/-?\d+/);
-	if (!match) return undefined;
-	const parsed = Number.parseInt(match[0], 10);
-	return Number.isFinite(parsed) ? parsed : undefined;
+	return roleReporting.parseFirstNumber(value);
 }
 
 async function gitHeadSha(cwd: string): Promise<string | undefined> {
@@ -2252,16 +2872,13 @@ function parseStructuredProgress(text: string): {
 }
 
 async function transcribeRoleOutput(role: CompletionRole, cwd: string, output: string, reportFields: Record<string, string>): Promise<TranscriptionResult> {
-	const result: TranscriptionResult = { appended: [], skipped: [], errors: [] };
 	const snapshot = await loadCompletionSnapshot(cwd);
 	if (!snapshot) {
-		result.skipped.push("No canonical completion snapshot found.");
-		return result;
+		return { appended: [], skipped: ["No canonical completion snapshot found."], errors: [] };
 	}
 	const headSha = await gitHeadSha(snapshot.files.root);
 	if (!headSha) {
-		result.errors.push("Could not resolve git HEAD for transcription.");
-		return result;
+		return { appended: [], skipped: [], errors: ["Could not resolve git HEAD for transcription."] };
 	}
 
 	const sliceId =
@@ -2269,117 +2886,14 @@ async function transcribeRoleOutput(role: CompletionRole, cwd: string, output: s
 		asString(snapshot.activeSlice?.slice_id) ??
 		asString(snapshot.state?.latest_completed_slice);
 
-		if (role === "completion-reviewer" || role === "completion-auditor") {
-		if (!sliceId) {
-			result.errors.push(`Missing slice_id for ${role} transcription.`);
-			return result;
-		}
-		const type = role === "completion-reviewer" ? "reviewed" : "audited";
-		const history = await readJsonl(snapshot.files.sliceHistoryPath);
-		const duplicate = history.some((entry) => {
-			return (
-				asString(entry.type) === type &&
-				asString(entry.slice_id) === sliceId &&
-				asString(entry.head_sha) === headSha &&
-				asString(entry.report_text) === output.trim()
-			);
-		});
-		if (duplicate) {
-			result.skipped.push(`Skipped duplicate ${type} record for slice ${sliceId} at ${headSha.slice(0, 12)}.`);
-			return result;
-		}
-		await appendJsonlRecord(snapshot.files.sliceHistoryPath, {
-			schema_version: 1,
-			type,
-			recorded_at: Date.now(),
-			slice_id: sliceId,
-			commit_sha: headSha,
-			head_sha: headSha,
-			role,
-			report_fields: reportFields,
-			report_text: output.trim(),
-		});
-		result.appended.push(`${type}:${sliceId}`);
-		return result;
-	}
-
-	if (role === "completion-stop-judge") {
-		const canStop = parseYesNo(reportFields["Can the project stop now"]);
-		const blockerCount = parseFirstNumber(reportFields["Blocker count"]);
-		const highValueGapCount = parseFirstNumber(reportFields["High-value gap count"]);
-		if (canStop === undefined || blockerCount === undefined || highValueGapCount === undefined) {
-			result.errors.push("Missing required stop-judge fields for canonical judgment transcription.");
-			return result;
-		}
-		const history = await readJsonl(snapshot.files.stopHistoryPath);
-		const duplicate = history.some((entry) => {
-			return asString(entry.type) === "judgment" && asString(entry.head_sha) === headSha && asString(entry.report_text) === output.trim();
-		});
-		if (duplicate) {
-			result.skipped.push(`Skipped duplicate judgment record at ${headSha.slice(0, 12)}.`);
-			return result;
-		}
-		await appendJsonlRecord(snapshot.files.stopHistoryPath, {
-			schema_version: 1,
-			type: "judgment",
-			recorded_at: Date.now(),
-			head_sha: headSha,
-			can_stop: canStop,
-			blocker_count: blockerCount,
-			high_value_gap_count: highValueGapCount,
-			role,
-			report_fields: reportFields,
-			report_text: output.trim(),
-		});
-		result.appended.push(`judgment:${headSha.slice(0, 12)}`);
-		return result;
-	}
-
-	if (role === "completion-regrounder") {
-		const rawDecision = asString(reportFields["Reconciliation decision"])?.toLowerCase();
-		const decision = rawDecision?.match(/\b(accepted|reopened|none)\b/)?.[1];
-		if (!decision || decision === "none") {
-			result.skipped.push("No reconciliation decision emitted by completion-regrounder.");
-			return result;
-		}
-		const reconciledSliceId =
-			asString(reportFields["Reconciled slice ID"]) ??
-			asString(reportFields["Current selected slice"]) ??
-			sliceId;
-		if (!reconciledSliceId || reconciledSliceId === "none" || reconciledSliceId === "(none)") {
-			result.errors.push("Missing reconciled slice id for completion-regrounder transcription.");
-			return result;
-		}
-		const history = await readJsonl(snapshot.files.sliceHistoryPath);
-		const duplicate = history.some((entry) => {
-			return (
-				asString(entry.type) === decision &&
-				asString(entry.slice_id) === reconciledSliceId &&
-				asString(entry.head_sha) === headSha &&
-				asString(entry.report_text) === output.trim()
-			);
-		});
-		if (duplicate) {
-			result.skipped.push(`Skipped duplicate ${decision} record for slice ${reconciledSliceId} at ${headSha.slice(0, 12)}.`);
-			return result;
-		}
-		await appendJsonlRecord(snapshot.files.sliceHistoryPath, {
-			schema_version: 1,
-			type: decision,
-			recorded_at: Date.now(),
-			slice_id: reconciledSliceId,
-			commit_sha: headSha,
-			head_sha: headSha,
-			role,
-			report_fields: reportFields,
-			report_text: output.trim(),
-		});
-		result.appended.push(`${decision}:${reconciledSliceId}`);
-		return result;
-	}
-
-	result.skipped.push(`No automatic transcription configured for ${role}.`);
-	return result;
+	return await roleReporting.transcribeCanonicalRoleReport({
+		role,
+		output,
+		reportFields,
+		snapshotFiles: snapshot.files,
+		headSha,
+		sliceId,
+	});
 }
 
 function isPathInside(root: string, candidatePath: string): boolean {
@@ -2483,18 +2997,24 @@ function lastAssistantText(messages: Array<{ role: string; content: Array<{ type
 	return "";
 }
 
-function completionKickoff(goal: string, intent: "auto" | "continue" | "refocus" = "auto", missionAnchor?: string): string {
+function completionKickoff(
+	goal: string,
+	taskType: string,
+	evaluationProfile: string,
+	intent: "auto" | "continue" | "refocus" = "auto",
+	missionAnchor?: string,
+): string {
 	const intentBlock =
 		intent === "continue" && missionAnchor
 			? `Existing canonical mission anchor:\n${missionAnchor}\n\nWorkflow intent:\n- Continue the existing workflow.\n- Treat the new user text as supplemental direction unless canonical reconciliation proves the mission itself must change.\n\n`
 			: intent === "refocus" && missionAnchor
 				? `Updated canonical mission anchor:\n${missionAnchor}\n\nWorkflow intent:\n- The user explicitly refocused the workflow before this kickoff.\n- Re-read canonical .agent/** state and continue from the refocused mission.\n\n`
 				: "";
-	return `/skill:completion-protocol Start or continue the completion workflow for this repo.\n\nBefore acting, read:\n- ${SKILL_PATH}\n- ${REFERENCE_PATH}\n\nUser goal:\n${goal}\n\n${intentBlock}Driver instructions:\n- Canonical truth is in .agent/**. Re-read .agent/state.json, .agent/plan.json, and .agent/active-slice.json before acting when they exist.\n- If tracked completion contract files are missing or onboarding is required, invoke completion_role with role completion-bootstrapper.\n- Otherwise follow the mandatory dispatch rules from completion-protocol.\n- Use completion_role for all completion-* role work. Do not directly implement tracked product changes yourself.\n- Continue dispatching mandatory roles while continuation_policy == continue.\n- Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.`;
+	return `/skill:completion-protocol Start or continue the completion workflow for this repo.\n\nBefore acting, read:\n- ${SKILL_PATH}\n- ${REFERENCE_PATH}\n\nCanonical routing profile:\n- task_type: ${taskType}\n- evaluation_profile: ${evaluationProfile}\n\nUser goal:\n${goal}\n\n${intentBlock}Driver instructions:\n- Canonical truth is in .agent/**. Re-read .agent/state.json, .agent/plan.json, and .agent/active-slice.json before acting when they exist.\n- If tracked completion contract files are missing or onboarding is required, invoke completion_role with role completion-bootstrapper.\n- Otherwise follow the mandatory dispatch rules from completion-protocol.\n- Use completion_role for all completion-* role work. Do not directly implement tracked product changes yourself.\n- Continue dispatching mandatory roles while continuation_policy == continue.\n- Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.`;
 }
 
-function completionResumePrompt(): string {
-	return `/skill:completion-protocol Resume the completion workflow from canonical state.\n\nBefore acting, read:\n- ${SKILL_PATH}\n- ${REFERENCE_PATH}\n\nResume instructions:\n- Re-read .agent/state.json, .agent/plan.json, and .agent/active-slice.json before acting.\n- If canonical state is missing, invalid, contradictory, stale, or ambiguous, route to completion-regrounder first.\n- Continue from next_mandatory_role and next_mandatory_action.\n- Use completion_role for all completion-* role work.\n- Continue dispatching mandatory roles while continuation_policy == continue.\n- Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.`;
+function completionResumePrompt(taskType: string, evaluationProfile: string): string {
+	return `/skill:completion-protocol Resume the completion workflow from canonical state.\n\nBefore acting, read:\n- ${SKILL_PATH}\n- ${REFERENCE_PATH}\n\nCanonical routing profile:\n- task_type: ${taskType}\n- evaluation_profile: ${evaluationProfile}\n\nResume instructions:\n- Re-read .agent/state.json, .agent/plan.json, and .agent/active-slice.json before acting.\n- If canonical state is missing, invalid, contradictory, stale, or ambiguous, route to completion-regrounder first.\n- Continue from next_mandatory_role and next_mandatory_action.\n- Use completion_role for all completion-* role work.\n- Continue dispatching mandatory roles while continuation_policy == continue.\n- Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.`;
 }
 
 export default function completionExtension(pi: ExtensionAPI) {
@@ -2529,6 +3049,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 		}
 		const additions = [buildSystemReminder(loaded.snapshot, loaded.sliceHistory, loaded.stopHistory)];
 		if (marker) additions.push(buildPostCompactionDriverInstructions(loaded.snapshot, marker));
+		maybeWriteTestSnapshot(completionTestSystemReminderPath(), additions.join("\n\n"));
 		const systemPrompt = getSystemPromptSafe(ctx);
 		if (!systemPrompt) return;
 		return {
@@ -2631,6 +3152,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			const runCwd = findCompletionRoot(cwd) ?? findRepoRoot(cwd) ?? cwd;
 			const rootKey = runCwd;
 			const agent = await loadAgentDefinition(runCwd, role);
+			const loaded = await loadCompletionDataForReminder(runCwd);
 			type RunningDetails = {
 				role: string;
 				status: "running" | "ok" | "error";
@@ -2660,6 +3182,9 @@ export default function completionExtension(pi: ExtensionAPI) {
 				`- ${REFERENCE_PATH}`,
 				"Use canonical .agent/** state as the source of truth.",
 			];
+			if (loaded && isRubricEvaluationRole(role)) {
+				taskLines.push("", ...buildEvaluationRoleContextLines(loaded.snapshot, role));
+			}
 			if (params.task?.trim()) {
 				taskLines.push("", "Supplemental task context:", params.task.trim());
 			}
@@ -2916,6 +3441,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 			const workflowDone = isWorkflowDone(snapshot);
 			let kickoffIntent: "auto" | "continue" | "refocus" = "auto";
 			let kickoffMissionAnchor = snapshot ? currentMissionAnchor(snapshot) : undefined;
+			let kickoffAnalysis: ContextProposalAnalysis | undefined;
 
 			if (!snapshot) {
 				const root = findRepoRoot(cwd) ?? cwd;
@@ -2941,6 +3467,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 					}
 					goal = decision.goalText;
 					kickoffMissionAnchor = decision.missionAnchor;
+					kickoffAnalysis = decision.analysis;
 				} else {
 					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
 					const decision = await confirmContextProposal(ctx, proposal, projectName, {
@@ -2955,8 +3482,17 @@ export default function completionExtension(pi: ExtensionAPI) {
 					}
 					goal = decision.goalText;
 					kickoffMissionAnchor = decision.missionAnchor;
+					kickoffAnalysis = decision.analysis;
 				}
-				const created = await scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName);
+				const startupRouting = finalizeContextProposalAnalysis(kickoffAnalysis, [goal ?? kickoffMissionAnchor ?? projectName]);
+				const created = await scaffoldCompletionFiles(root, kickoffMissionAnchor ?? projectName, {
+					analysis: startupRouting,
+					continuationReason: buildContextProposalContinuationReason(
+						"User started workflow via /cook:",
+						goal ?? kickoffMissionAnchor ?? projectName,
+						startupRouting,
+					),
+				});
 				emitCommandText(
 					ctx,
 					`Initialized completion control plane in ${created.root}${created.created.length > 0 ? ` (${created.created.length} files created)` : ""}`,
@@ -2992,17 +3528,22 @@ export default function completionExtension(pi: ExtensionAPI) {
 					goal = decision.goalText;
 					kickoffIntent = "refocus";
 					kickoffMissionAnchor = decision.missionAnchor;
-					await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText);
+					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 recent discussion: ${decision.missionAnchor}`, "info");
 				} else {
 					const mission = currentMissionAnchor(snapshot);
 					pi.setSessionName(`completion: ${mission.slice(0, 60)}`);
+					const resumePrompt = completionResumePrompt(
+						currentTaskType(snapshot) ?? "(missing)",
+						currentEvaluationProfile(snapshot) ?? "(missing)",
+					);
+					maybeWriteTestSnapshot(completionTestDriverPromptPath(), `${resumePrompt}\n`);
 					if (shouldSkipDriverKickoffForTests()) {
 						emitCommandText(ctx, "Skipped completion workflow resume kickoff (test mode)", "info");
 						return;
 					}
-					pi.sendUserMessage(completionResumePrompt());
+					pi.sendUserMessage(resumePrompt);
 					emitCommandText(ctx, "Queued completion workflow resume", "info");
 					return;
 				}
@@ -3025,7 +3566,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 					goal = decision.goalText;
 					kickoffIntent = "refocus";
 					kickoffMissionAnchor = decision.missionAnchor;
-					await refocusCompletionMission(snapshot, decision.missionAnchor, decision.goalText);
+					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 {
@@ -3050,7 +3591,12 @@ export default function completionExtension(pi: ExtensionAPI) {
 							return;
 						}
 						goal = proposalDecision.goalText;
-						await refocusCompletionMission(snapshot, proposalDecision.missionAnchor, 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");
@@ -3060,11 +3606,19 @@ export default function completionExtension(pi: ExtensionAPI) {
 				}
 			}
 			pi.setSessionName(`completion: ${kickoffMissionAnchor.slice(0, 60)}`);
+			const kickoffPrompt = completionKickoff(
+				goal,
+				currentTaskType(snapshot) ?? "(missing)",
+				currentEvaluationProfile(snapshot) ?? "(missing)",
+				kickoffIntent,
+				kickoffMissionAnchor,
+			);
+			maybeWriteTestSnapshot(completionTestDriverPromptPath(), `${kickoffPrompt}\n`);
 			if (shouldSkipDriverKickoffForTests()) {
 				emitCommandText(ctx, "Skipped completion workflow kickoff (test mode)", "info");
 				return;
 			}
-			pi.sendUserMessage(completionKickoff(goal, kickoffIntent, kickoffMissionAnchor));
+			pi.sendUserMessage(kickoffPrompt);
 			emitCommandText(ctx, "Queued completion workflow kickoff", "info");
 		},
 	});