@linimin/pi-letscook 0.1.33 → 0.1.36

package/extensions/completion/index.ts

@@ -50,6 +50,7 @@ type CompletionFiles = {
 	activePath: string;
 	sliceHistoryPath: string;
 	stopHistoryPath: string;
+	verificationEvidencePath: string;
 	compactionMarkerPath: string;
 };
 
@@ -59,6 +60,7 @@ type CompletionStateSnapshot = {
 	state?: JsonRecord;
 	plan?: JsonRecord;
 	active?: JsonRecord;
+	verificationEvidence?: JsonRecord;
 	activeSlice?: JsonRecord;
 };
 
@@ -146,7 +148,7 @@ type ContextProposalDecision = {
 	analysis: ContextProposalAnalysis;
 };
 
-type ContextProposalConfirmAction = "start" | "edit" | "cancel";
+type ContextProposalConfirmAction = "start" | "cancel";
 
 type ContextProposalConfirmationActionItem = {
 	id: ContextProposalConfirmAction;
@@ -171,7 +173,6 @@ type ContextProposalConfirmationLayout = {
 type ContextProposalConfirmOptions = {
 	title: string;
 	nonInteractiveBehavior?: "accept" | "cancel";
-	editorPrompt?: string;
 };
 
 class StartupAnalystOverlay extends Container {
@@ -275,6 +276,7 @@ function resolveFiles(root: string): CompletionFiles {
 		activePath: path.join(agentDir, "active-slice.json"),
 		sliceHistoryPath: path.join(agentDir, "slice-history.jsonl"),
 		stopHistoryPath: path.join(agentDir, "stop-check-history.jsonl"),
+		verificationEvidencePath: path.join(agentDir, "verification-evidence.json"),
 		compactionMarkerPath: path.join(tmpDir, "post-compaction-recovery.json"),
 	};
 }
@@ -290,14 +292,24 @@ function walkUpForDir(startCwd: string, segments: string[]): string | undefined
 	}
 }
 
+function completionSearchRoots(startCwd: string): string[] {
+	return [...new Set([path.resolve(startCwd), path.resolve(process.cwd())])];
+}
+
 function findCompletionRoot(startCwd: string): string | undefined {
-	const profilePath = walkUpForDir(startCwd, [".agent", "profile.json"]);
-	return profilePath ? path.dirname(path.dirname(profilePath)) : undefined;
+	for (const candidateRoot of completionSearchRoots(startCwd)) {
+		const profilePath = walkUpForDir(candidateRoot, [".agent", "profile.json"]);
+		if (profilePath) return path.dirname(path.dirname(profilePath));
+	}
+	return undefined;
 }
 
 function findRepoRoot(startCwd: string): string | undefined {
-	const gitPath = walkUpForDir(startCwd, [".git"]);
-	return gitPath ? path.dirname(gitPath) : undefined;
+	for (const candidateRoot of completionSearchRoots(startCwd)) {
+		const gitPath = walkUpForDir(candidateRoot, [".git"]);
+		if (gitPath) return path.dirname(gitPath);
+	}
+	return undefined;
 }
 
 async function readJson(filePath: string): Promise<JsonRecord | undefined> {
@@ -354,12 +366,14 @@ async function loadCompletionSnapshot(startCwd: string): Promise<CompletionState
 	const state = await readJson(files.statePath);
 	const plan = await readJson(files.planPath);
 	const active = await readJson(files.activePath);
+	const verificationEvidence = await readJson(files.verificationEvidencePath);
 	return {
 		files,
 		profile,
 		state,
 		plan,
 		active,
+		verificationEvidence,
 		activeSlice: findActiveSlice(plan, active),
 	};
 }
@@ -439,92 +453,37 @@ function isWeakMissionAnchor(value: string): boolean {
 
 type MissionAnchorAssessment = {
 	derived: string;
-	needsConfirmation: boolean;
-	reason?: string;
 };
 
 function assessMissionAnchor(rawGoal: string, projectName: string): MissionAnchorAssessment {
-	const normalized = normalizeMissionAnchorText(rawGoal);
-	const derived = deriveMissionAnchor(rawGoal, projectName);
-	if (!normalized) {
-		return {
-			derived,
-			needsConfirmation: true,
-			reason: "No meaningful goal text was provided.",
-		};
-	}
-	if (isWeakMissionAnchor(normalized)) {
-		return {
-			derived,
-			needsConfirmation: true,
-			reason: "The goal is too short or vague for stable canonical workflow state.",
-		};
-	}
-	const vaguePronouns = /\b(this|that|it|things|stuff|something)\b/i.test(normalized);
-	const fallback = derived === `Drive ${projectName} to truthful, verifiable completion.`;
-	if (fallback || vaguePronouns) {
-		return {
-			derived,
-			needsConfirmation: true,
-			reason: fallback
-				? "The initial goal was too ambiguous, so the workflow fell back to a generic repo-based mission."
-				: "The goal still contains ambiguous references that are better confirmed before writing canonical state.",
-		};
-	}
-	return { derived, needsConfirmation: false };
-}
-
-async function confirmMissionAnchor(
-	ctx: { hasUI: boolean; ui: any },
-	assessment: MissionAnchorAssessment,
-): Promise<string | undefined> {
-	if (!getCtxHasUI(ctx)) return assessment.derived;
-	const ui = getCtxUi(ctx);
-	if (!ui) return assessment.derived;
-	if (!assessment.needsConfirmation) return assessment.derived;
-	const title = "Confirm mission anchor";
-	const reason = assessment.reason ? `${assessment.reason}\n\n` : "";
-	const choice = await ui.select(
-		title,
-		[
-			`${reason}Proposed mission anchor:\n${assessment.derived}\n\nUse proposed mission anchor`,
-			"Edit mission anchor",
-			"Cancel",
-		],
-	);
-	if (!choice || choice === "Cancel") return undefined;
-	if (choice === "Edit mission anchor") {
-		const edited = await ui.editor(title, assessment.derived);
-		return edited?.trim() ? edited.trim() : undefined;
-	}
-	return assessment.derived;
+	return { derived: deriveMissionAnchor(rawGoal, projectName) };
 }
 
 type ExistingWorkflowDecision =
 	| { action: "continue"; currentMissionAnchor: string }
 	| { action: "refocus"; currentMissionAnchor: string; missionAnchor: string };
 
-function completionTestWorkflowActionOverride(): "continue" | "refocus" | undefined {
+function completionTestWorkflowActionOverride(): "continue" | "refocus" | "cancel" | undefined {
 	const raw = process.env.PI_COMPLETION_EXISTING_WORKFLOW_ACTION?.trim().toLowerCase();
-	return raw === "continue" || raw === "refocus" ? raw : undefined;
+	return raw === "continue" || raw === "refocus" || raw === "cancel" ? raw : undefined;
 }
 
 function shouldSkipDriverKickoffForTests(): boolean {
 	return process.env.PI_COMPLETION_SKIP_DRIVER_KICKOFF === "1";
 }
 
-function completionTestContextProposalActionOverride(): "accept" | "edit" | "cancel" | undefined {
+function completionTestContextProposalActionOverride(): "accept" | "cancel" | undefined {
 	const raw = process.env.PI_COMPLETION_CONTEXT_PROPOSAL_ACTION?.trim().toLowerCase();
-	return raw === "accept" || raw === "edit" || raw === "cancel" ? raw : undefined;
-}
-
-function completionTestContextProposalEditText(): string | undefined {
-	return asString(process.env.PI_COMPLETION_CONTEXT_PROPOSAL_EDIT_TEXT);
+	return raw === "accept" || raw === "cancel" ? raw : undefined;
 }
 
 function completionTestContextProposalUiActionOverride(): ContextProposalConfirmAction | undefined {
 	const raw = process.env.PI_COMPLETION_TEST_CONTEXT_PROPOSAL_UI_ACTION?.trim().toLowerCase();
-	return raw === "start" || raw === "edit" || raw === "cancel" ? raw : undefined;
+	return raw === "start" || raw === "cancel" ? raw : undefined;
+}
+
+function completionTestExistingWorkflowChooserSnapshotPath(): string | undefined {
+	return asString(process.env.PI_COMPLETION_TEST_EXISTING_WORKFLOW_CHOOSER_PATH);
 }
 
 function completionTestContextProposalUiSnapshotPath(): string | undefined {
@@ -561,6 +520,12 @@ function maybeWriteTestSnapshot(targetPath: string | undefined, content: string)
 	}
 }
 
+const COOK_MAIN_CHAT_RERUN_GUIDANCE = "Discuss changes in the main chat and rerun /cook.";
+
+function buildCookCancellationMessage(prefix: string): string {
+	return `${prefix}. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
+}
+
 function shouldDisableContextProposalAnalyst(): boolean {
 	return process.env.PI_COMPLETION_DISABLE_CONTEXT_PROPOSAL_ANALYST === "1";
 }
@@ -1210,15 +1175,10 @@ function buildContextProposalConfirmationActions(): ContextProposalConfirmationA
 			label: "Start",
 			description: "Accept this proposal and let /cook write or refocus canonical workflow state.",
 		},
-		{
-			id: "edit",
-			label: "Edit",
-			description: "Open the existing proposal editor before starting the workflow.",
-		},
 		{
 			id: "cancel",
 			label: "Cancel",
-			description: "Exit without changing canonical workflow state.",
+			description: `Stop here without changing canonical workflow state. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`,
 		},
 	];
 }
@@ -1230,7 +1190,7 @@ function buildContextProposalConfirmationLayout(
 	const analysis = finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]);
 	return {
 		title,
-		intro: "Review the proposed mission, scope, constraints, acceptance, critique, and routing 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. This gate is approval-only: either Start it as-is or Cancel, discuss changes in the main chat, and rerun /cook.",
 		proposalHeading: "Proposed workflow",
 		proposalBody: buildContextProposalDisplayText(proposal),
 		critiqueHeading: "Critique and risks",
@@ -1282,7 +1242,7 @@ async function promptContextProposalConfirmationAction(
 		const container = new Container();
 		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
 		container.addChild(new Text(theme.fg("accent", theme.bold(layout.title)), 1, 0));
-		container.addChild(new Text(theme.fg("dim", layout.intro), 1, 0));
+		container.addChild(new Text(layout.intro, 1, 0));
 		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));
@@ -1302,13 +1262,13 @@ async function promptContextProposalConfirmationAction(
 			selectedPrefix: (text) => theme.fg("accent", text),
 			selectedText: (text) => theme.fg("accent", text),
 			description: (text) => theme.fg("muted", text),
-			scrollInfo: (text) => theme.fg("dim", text),
+			scrollInfo: (text) => text,
 			noMatch: (text) => theme.fg("warning", text),
 		});
 		selectList.onSelect = (item) => done(item.value as ContextProposalConfirmAction);
 		selectList.onCancel = () => done(undefined);
 		container.addChild(selectList);
-		container.addChild(new Text(theme.fg("dim", layout.footer), 1, 0));
+		container.addChild(new Text(layout.footer, 1, 0));
 		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
 
 		return {
@@ -1326,60 +1286,16 @@ async function promptContextProposalConfirmationAction(
 	});
 }
 
-async function resolveEditedContextProposalDecision(
-	ctx: { hasUI: boolean; ui: any },
-	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,
-			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(), analysis };
-	}
-	const missionAnchor = await confirmMissionAnchor(ctx, assessment);
-	if (!missionAnchor) return undefined;
-	return { missionAnchor, goalText: editedText.trim(), analysis };
-}
-
 async function resolveContextProposalConfirmationAction(
-	ctx: { hasUI: boolean; ui: any },
 	proposal: ContextProposal,
-	projectName: string,
-	options: ContextProposalConfirmOptions,
 	action: ContextProposalConfirmAction,
-	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, analysis };
-	}
-	const editedText =
-		editedTextOverride ??
-		(await getCtxUi(ctx)?.editor(
-			options.editorPrompt ?? `${options.title}\n\nEdit the proposed mission, scope, constraints, and acceptance details below.`,
-			buildContextProposalEditorText(proposal),
-		));
-	if (!editedText?.trim()) return undefined;
-	return await resolveEditedContextProposalDecision(ctx, projectName, editedText, editedTextOverride === undefined, analysis);
-}
-
-function buildContextProposalEditorText(proposal: ContextProposal): string {
-	return buildContextProposalGoalText(proposal);
+	return {
+		missionAnchor: proposal.mission,
+		goalText: proposal.goalText,
+		analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
+	};
 }
 
 function parseContextProposal(text: string, projectName: string): ContextProposal | undefined {
@@ -1571,65 +1487,34 @@ async function buildGoalAnchoredContextProposal(
 async function confirmContextProposal(
 	ctx: { hasUI: boolean; ui: any },
 	proposal: ContextProposal,
-	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,
-			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,
-			finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
-		);
+		return await resolveContextProposalConfirmationAction(proposal, "start");
 	}
 	const layout = buildContextProposalConfirmationLayout(options.title, proposal);
 	maybeWriteContextProposalConfirmationSnapshot(layout);
 	const uiActionOverride = completionTestContextProposalUiActionOverride();
 	if (uiActionOverride) {
-		return await resolveContextProposalConfirmationAction(
-			ctx,
-			proposal,
-			projectName,
-			options,
-			uiActionOverride,
-			uiActionOverride === "edit" ? completionTestContextProposalEditText() : undefined,
-		);
+		return await resolveContextProposalConfirmationAction(proposal, uiActionOverride);
 	}
 	if (!getCtxHasUI(ctx)) {
 		return options.nonInteractiveBehavior === "accept"
-			? {
-				missionAnchor: proposal.mission,
-				goalText: proposal.goalText,
-				analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
-			}
+			? await resolveContextProposalConfirmationAction(proposal, "start")
 			: undefined;
 	}
 	const ui = getCtxUi(ctx);
 	if (!ui) {
 		return options.nonInteractiveBehavior === "accept"
-			? {
-				missionAnchor: proposal.mission,
-				goalText: proposal.goalText,
-				analysis: finalizeContextProposalAnalysis(proposal.analysis, [proposal.goalText, proposal.mission]),
-			}
+			? await resolveContextProposalConfirmationAction(proposal, "start")
 			: undefined;
 	}
 	const choice = await promptContextProposalConfirmationAction(ui, layout);
 	if (!choice) return undefined;
-	return await resolveContextProposalConfirmationAction(ctx, proposal, projectName, options, choice);
+	return await resolveContextProposalConfirmationAction(proposal, choice);
 }
 
 function currentMissionAnchor(snapshot: CompletionStateSnapshot): string {
@@ -1809,8 +1694,29 @@ function activeSliceContext(snapshot: CompletionStateSnapshot) {
 	};
 }
 
+function verificationEvidenceContext(snapshot: CompletionStateSnapshot) {
+	const evidence = snapshot.verificationEvidence;
+	return {
+		path: path.relative(snapshot.files.root, snapshot.files.verificationEvidencePath) || ".agent/verification-evidence.json",
+		status: evidence ? "present" : "missing",
+		subjectType: asString(evidence?.subject_type),
+		sliceId: asString(evidence?.slice_id),
+		goal: asString(evidence?.goal),
+		contractIds: asStringArray(evidence?.contract_ids),
+		basisCommit: asString(evidence?.basis_commit),
+		headSha: asString(evidence?.head_sha),
+		verificationCommands: asStringArray(evidence?.verification_commands),
+		outcome: asString(evidence?.outcome),
+		recordedAt: asString(evidence?.recorded_at),
+		summary:
+			asString(evidence?.summary) ??
+			(evidence ? "Canonical verification evidence is present but its summary is missing." : "Canonical verification evidence is missing."),
+	};
+}
+
 function buildEvaluationRoleContextLines(snapshot: CompletionStateSnapshot, role: RubricEvaluationRole): string[] {
 	const context = activeSliceContext(snapshot);
+	const evidence = verificationEvidenceContext(snapshot);
 	const lines = [
 		`Canonical evaluation handoff for ${role}:`,
 		`- task_type: ${currentTaskType(snapshot) ?? "(missing)"}`,
@@ -1829,6 +1735,17 @@ function buildEvaluationRoleContextLines(snapshot: CompletionStateSnapshot, role
 		`- 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)"}`,
+		`- verification_evidence_path: ${evidence.path}`,
+		`- verification_evidence_status: ${evidence.status}`,
+		`- verification_evidence_subject_type: ${evidence.subjectType ?? "(missing)"}`,
+		`- verification_evidence_slice_id: ${evidence.sliceId ?? "(none)"}`,
+		`- verification_evidence_contract_ids: ${evidence.contractIds.length > 0 ? evidence.contractIds.join(", ") : "(none)"}`,
+		`- verification_evidence_outcome: ${evidence.outcome ?? "(missing)"}`,
+		`- verification_evidence_recorded_at: ${evidence.recordedAt ?? "(missing)"}`,
+		`- verification_evidence_head_sha: ${evidence.headSha ?? "(missing)"}`,
+		`- verification_evidence_basis_commit: ${evidence.basisCommit ?? "(missing)"}`,
+		`- verification_evidence_commands: ${evidence.verificationCommands.length > 0 ? evidence.verificationCommands.join(" | ") : "(none)"}`,
+		`- verification_evidence_summary: ${evidence.summary}`,
 	];
 	return lines;
 }
@@ -1850,6 +1767,25 @@ async function confirmExistingWorkflowGoal(
 	if (!normalizedGoal || normalizedGoal === normalizedCurrent || normalizedProposed === normalizedCurrent) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
+	const title = [
+		"Existing completion workflow found",
+		"",
+		"A workflow is already in progress. Choose how /cook should proceed:",
+		"",
+		"Current mission",
+		currentMission,
+		"",
+		"New proposed mission",
+		assessment.derived,
+	].join("\n");
+	const continueChoice = "Continue current workflow\n\nKeep the current mission and treat the new goal as extra direction only.";
+	const refocusChoice =
+		"Abandon current workflow and start this new one\n\nReview the proposed replacement in a final Start/Cancel confirmation before /cook rewrites canonical workflow state.";
+	const cancelChoice = `Cancel\n\nKeep the current workflow unchanged. ${COOK_MAIN_CHAT_RERUN_GUIDANCE}`;
+	maybeWriteTestSnapshot(
+		completionTestExistingWorkflowChooserSnapshotPath(),
+		`${JSON.stringify({ title, choices: [continueChoice, refocusChoice, cancelChoice] }, null, 2)}\n`,
+	);
 	const actionOverride = completionTestWorkflowActionOverride();
 	if (actionOverride === "continue") {
 		return { action: "continue", currentMissionAnchor: currentMission };
@@ -1857,6 +1793,7 @@ async function confirmExistingWorkflowGoal(
 	if (actionOverride === "refocus") {
 		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: assessment.derived };
 	}
+	if (actionOverride === "cancel") return undefined;
 	if (!getCtxHasUI(ctx)) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
@@ -1864,26 +1801,10 @@ async function confirmExistingWorkflowGoal(
 	if (!ui) {
 		return { action: "continue", currentMissionAnchor: currentMission };
 	}
-	const title = [
-		"Existing completion workflow found",
-		"",
-		"A workflow is already in progress. Choose how /cook should proceed:",
-		"",
-		"Current mission",
-		currentMission,
-		"",
-		"New proposed mission",
-		assessment.derived,
-	].join("\n");
-	const continueChoice = "Continue current workflow\n\nKeep the current mission and treat the new goal as extra direction only.";
-	const refocusChoice = "Abandon current workflow and start this new one\n\nReplace the current mission with the new goal, then rebuild canonical state from that new direction.";
-	const cancelChoice = "Cancel\n\nExit without changing the current workflow.";
 	const choice = await ui.select(title, [continueChoice, refocusChoice, cancelChoice]);
 	if (!choice || choice === cancelChoice) return undefined;
 	if (choice === refocusChoice) {
-		const missionAnchor = await confirmMissionAnchor(ctx, assessment);
-		if (!missionAnchor) return undefined;
-		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor };
+		return { action: "refocus", currentMissionAnchor: currentMission, missionAnchor: assessment.derived };
 	}
 	return { action: "continue", currentMissionAnchor: currentMission };
 }
@@ -1926,6 +1847,7 @@ async function refocusCompletionMission(
 		writeJsonFile(snapshot.files.statePath, nextState),
 		writeJsonFile(snapshot.files.planPath, nextPlan),
 		writeJsonFile(snapshot.files.activePath, nextActive),
+		writeJsonFile(snapshot.files.verificationEvidencePath, defaultVerificationEvidence()),
 	]);
 }
 
@@ -2043,8 +1965,25 @@ function defaultActiveSlice(
 	};
 }
 
+function defaultVerificationEvidence(): JsonRecord {
+	return {
+		schema_version: 1,
+		artifact_type: "completion-verification-evidence",
+		subject_type: "none",
+		slice_id: null,
+		goal: null,
+		contract_ids: [],
+		basis_commit: null,
+		head_sha: null,
+		verification_commands: [],
+		outcome: "not_recorded",
+		recorded_at: null,
+		summary: "No deterministic verification evidence is recorded yet because no selected slice or current-HEAD verification subject exists.",
+	};
+}
+
 function buildAgentReadme(projectName: string): string {
-	return `# Completion Control Plane\n\nThis repository uses the \`completion\` workflow for long-running coding tasks.\n\n## Canonical tracked contract files\n\n- \`.agent/README.md\`\n- \`.agent/mission.md\`\n- \`.agent/profile.json\`\n- \`.agent/verify_completion_stop.sh\`\n- \`.agent/verify_completion_control_plane.sh\`\n\n## Ignored canonical execution state\n\n- \`.agent/state.json\`\n- \`.agent/plan.json\`\n- \`.agent/active-slice.json\`\n- \`.agent/slice-history.jsonl\`\n- \`.agent/stop-check-history.jsonl\`\n- \`.agent/*.log\`\n- \`.agent/tmp/\`\n\nThe source of truth for long-running completion work is canonical \`.agent/**\` state plus current repo truth.\n\nProject: ${projectName}\n`;
+	return `# Completion Control Plane\n\nThis repository uses the \`completion\` workflow for long-running coding tasks.\n\n## Canonical tracked contract files\n\n- \`.agent/README.md\`\n- \`.agent/mission.md\`\n- \`.agent/profile.json\`\n- \`.agent/verify_completion_stop.sh\`\n- \`.agent/verify_completion_control_plane.sh\`\n\n## Ignored canonical execution state\n\n- \`.agent/state.json\`\n- \`.agent/plan.json\`\n- \`.agent/active-slice.json\`\n- \`.agent/slice-history.jsonl\`\n- \`.agent/stop-check-history.jsonl\`\n- \`.agent/verification-evidence.json\`\n- \`.agent/*.log\`\n- \`.agent/tmp/\`\n\n\`.agent/verification-evidence.json\` is the durable canonical record of deterministic verification for the selected slice or current HEAD. Recovery, review, audit, and stop-check reminder surfaces consume it instead of temp-only artifacts or conversational summaries when it is populated.\n\nThe source of truth for long-running completion work is canonical \`.agent/**\` state plus current repo truth.\n\nProject: ${projectName}\n`;
 }
 
 function buildMission(projectName: string, missionAnchor: string): string {
@@ -2070,11 +2009,13 @@ for file in \
   .agent/verify_completion_control_plane.sh \
   .agent/state.json \
   .agent/plan.json \
-  .agent/active-slice.json; do
+  .agent/active-slice.json \
+  .agent/verification-evidence.json; do
   [[ -e "$file" ]] || { echo "missing required file: $file"; exit 1; }
 done
 
 node <<'NODE'
+const childProcess = require('node:child_process');
 const fs = require('node:fs');
 
 const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -2097,8 +2038,10 @@ const requireKeys = (object, required, label) => {
     assert(Object.prototype.hasOwnProperty.call(object, key), label + ': missing required field: ' + key);
   }
 };
+const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+const sameStringArrays = (left, right) => left.length === right.length && left.every((item, index) => item === right[index]);
 
-for (const file of ['.agent/profile.json', '.agent/state.json', '.agent/plan.json', '.agent/active-slice.json']) {
+for (const file of ['.agent/profile.json', '.agent/state.json', '.agent/plan.json', '.agent/active-slice.json', '.agent/verification-evidence.json']) {
   readJson(file);
 }
 
@@ -2106,11 +2049,13 @@ 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');
+const evidence = readJson('.agent/verification-evidence.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');
+assert(isObject(evidence), '.agent/verification-evidence.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');
@@ -2141,6 +2086,8 @@ assert(isStringArray(state.release_blocker_ids), '.agent/state.json: release_blo
 
 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 planMirrorFields = ['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 allowedSlice = [...requiredSlice, ...planMirrorFields];
 const sliceStatuses = ['planned', 'selected', 'in_progress', 'blocked', 'done', 'cancelled'];
 requireKeys(plan, requiredPlan, '.agent/plan.json');
 hasOnlyKeys(plan, requiredPlan, '.agent/plan.json');
@@ -2151,7 +2098,7 @@ 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);
+  hasOnlyKeys(slice, allowedSlice, 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');
@@ -2161,6 +2108,14 @@ for (const [index, slice] of plan.candidate_slices.entries()) {
   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');
+  if (hasOwn(slice, 'locked_notes')) assert(isStringArray(slice.locked_notes), label + ': locked_notes must be an array of strings when present');
+  if (hasOwn(slice, 'must_fix_findings')) assert(isStringArray(slice.must_fix_findings), label + ': must_fix_findings must be an array of strings when present');
+  if (hasOwn(slice, 'implementation_surfaces')) assert(isStringArray(slice.implementation_surfaces), label + ': implementation_surfaces must be an array of strings when present');
+  if (hasOwn(slice, 'verification_commands')) assert(isStringArray(slice.verification_commands), label + ': verification_commands must be an array of strings when present');
+  if (hasOwn(slice, 'basis_commit')) assert(isNonEmptyString(slice.basis_commit), label + ': basis_commit must be a non-empty string when present');
+  if (hasOwn(slice, 'remaining_contract_ids_before')) assert(isStringArray(slice.remaining_contract_ids_before), label + ': remaining_contract_ids_before must be an array of strings when present');
+  if (hasOwn(slice, 'release_blocker_count_before')) assert(typeof slice.release_blocker_count_before === 'number' && Number.isFinite(slice.release_blocker_count_before), label + ': release_blocker_count_before must be a finite number when present');
+  if (hasOwn(slice, 'high_value_gap_count_before')) assert(typeof slice.high_value_gap_count_before === 'number' && Number.isFinite(slice.high_value_gap_count_before), label + ': high_value_gap_count_before must be a finite number when present');
 }
 
 const isNonEmptyStringArray = (value) => Array.isArray(value) && value.length > 0 && value.every((item) => isNonEmptyString(item));
@@ -2181,6 +2136,23 @@ assert(isStringArray(active.implementation_surfaces), '.agent/active-slice.json:
 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');
 
+const requiredEvidence = ['schema_version', 'artifact_type', 'subject_type', 'slice_id', 'goal', 'contract_ids', 'basis_commit', 'head_sha', 'verification_commands', 'outcome', 'recorded_at', 'summary'];
+const evidenceSubjectTypes = ['none', 'selected_slice', 'current_head'];
+const evidenceOutcomes = ['not_recorded', 'passed', 'failed'];
+requireKeys(evidence, requiredEvidence, '.agent/verification-evidence.json');
+hasOnlyKeys(evidence, requiredEvidence, '.agent/verification-evidence.json');
+assert(evidence.artifact_type === 'completion-verification-evidence', '.agent/verification-evidence.json: artifact_type must be completion-verification-evidence');
+assert(evidenceSubjectTypes.includes(evidence.subject_type), '.agent/verification-evidence.json: invalid subject_type');
+assert(evidence.slice_id === null || isNonEmptyString(evidence.slice_id), '.agent/verification-evidence.json: slice_id must be null or a non-empty string');
+assert(evidence.goal === null || isNonEmptyString(evidence.goal), '.agent/verification-evidence.json: goal must be null or a non-empty string');
+assert(isStringArray(evidence.contract_ids), '.agent/verification-evidence.json: contract_ids must be an array of strings');
+assert(evidence.basis_commit === null || isNonEmptyString(evidence.basis_commit), '.agent/verification-evidence.json: basis_commit must be null or a non-empty string');
+assert(evidence.head_sha === null || isNonEmptyString(evidence.head_sha), '.agent/verification-evidence.json: head_sha must be null or a non-empty string');
+assert(isStringArray(evidence.verification_commands), '.agent/verification-evidence.json: verification_commands must be an array of strings');
+assert(evidenceOutcomes.includes(evidence.outcome), '.agent/verification-evidence.json: invalid outcome');
+assert(evidence.recorded_at === null || (isNonEmptyString(evidence.recorded_at) && !Number.isNaN(Date.parse(evidence.recorded_at))), '.agent/verification-evidence.json: recorded_at must be null or an ISO-8601 string');
+assert(isNonEmptyString(evidence.summary), '.agent/verification-evidence.json: summary must be a non-empty string');
+
 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');
@@ -2198,7 +2170,80 @@ if (requiresExactHandoff) {
   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');
+
+  const planSlice = plan.candidate_slices.find((slice) => isObject(slice) && slice.slice_id === active.slice_id);
+  assert(isObject(planSlice), '.agent/active-slice.json: slice_id must match a slice in .agent/plan.json when status carries an exact handoff');
+  const drift = [];
+  if (planSlice.goal !== active.goal) drift.push('goal');
+  if (!sameStringArrays(planSlice.contract_ids, active.contract_ids)) drift.push('contract_ids');
+  if (!sameStringArrays(planSlice.acceptance_criteria, active.acceptance_criteria)) drift.push('acceptance_criteria');
+  if (!sameStringArrays(planSlice.blocked_on, active.blocked_on)) drift.push('blocked_on');
+  if (planSlice.priority !== active.priority) drift.push('priority');
+  if (planSlice.why_now !== active.why_now) drift.push('why_now');
+
+  const expectPlanArrayMirror = (field) => {
+    if (!hasOwn(planSlice, field) || !sameStringArrays(planSlice[field], active[field])) drift.push(field);
+  };
+  const expectPlanStringMirror = (field) => {
+    if (!hasOwn(planSlice, field) || planSlice[field] !== active[field]) drift.push(field);
+  };
+  const expectPlanNumberMirror = (field) => {
+    if (!hasOwn(planSlice, field) || planSlice[field] !== active[field]) drift.push(field);
+  };
+
+  expectPlanArrayMirror('implementation_surfaces');
+  expectPlanArrayMirror('verification_commands');
+  expectPlanArrayMirror('locked_notes');
+  expectPlanArrayMirror('must_fix_findings');
+  expectPlanStringMirror('basis_commit');
+  expectPlanArrayMirror('remaining_contract_ids_before');
+  expectPlanNumberMirror('release_blocker_count_before');
+  expectPlanNumberMirror('high_value_gap_count_before');
+  assert(drift.length === 0, '.agent/active-slice.json must match the selected .agent/plan.json slice across: ' + Array.from(new Set(drift)).join(', '));
+}
+
+const currentHead = (() => {
+  try {
+    return childProcess.execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+})();
+
+if (requiresExactHandoff) {
+  assert(evidence.subject_type === 'selected_slice', '.agent/verification-evidence.json: subject_type must be selected_slice when active slice exact handoff requires verification evidence');
+  assert(evidence.slice_id === active.slice_id, '.agent/verification-evidence.json: slice_id must match .agent/active-slice.json when active slice exact handoff requires verification evidence');
+  assert(evidence.goal === active.goal, '.agent/verification-evidence.json: goal must match .agent/active-slice.json when active slice exact handoff requires verification evidence');
+  assert(sameStringArrays(evidence.contract_ids, active.contract_ids), '.agent/verification-evidence.json: contract_ids must match .agent/active-slice.json when active slice exact handoff requires verification evidence');
+  assert(evidence.basis_commit === active.basis_commit, '.agent/verification-evidence.json: basis_commit must match .agent/active-slice.json when active slice exact handoff requires verification evidence');
+  assert(sameStringArrays(evidence.verification_commands, active.verification_commands), '.agent/verification-evidence.json: verification_commands must match .agent/active-slice.json when active slice exact handoff requires verification evidence');
+  assert(evidence.outcome === 'passed', '.agent/verification-evidence.json: outcome must be passed when active slice exact handoff requires verification evidence');
+  assert(isNonEmptyString(evidence.recorded_at) && !Number.isNaN(Date.parse(evidence.recorded_at)), '.agent/verification-evidence.json: recorded_at must be an ISO-8601 string when active slice exact handoff requires verification evidence');
+  if (currentHead) assert(evidence.head_sha === currentHead, '.agent/verification-evidence.json: head_sha must match current git HEAD when active slice exact handoff requires verification evidence');
+} else if (evidence.subject_type === 'none') {
+  assert(evidence.slice_id === null, '.agent/verification-evidence.json: slice_id must be null when subject_type is none');
+  assert(evidence.goal === null, '.agent/verification-evidence.json: goal must be null when subject_type is none');
+  assert(evidence.contract_ids.length === 0, '.agent/verification-evidence.json: contract_ids must be empty when subject_type is none');
+  assert(evidence.basis_commit === null, '.agent/verification-evidence.json: basis_commit must be null when subject_type is none');
+  assert(evidence.head_sha === null, '.agent/verification-evidence.json: head_sha must be null when subject_type is none');
+  assert(evidence.verification_commands.length === 0, '.agent/verification-evidence.json: verification_commands must be empty when subject_type is none');
+  assert(evidence.outcome === 'not_recorded', '.agent/verification-evidence.json: outcome must be not_recorded when subject_type is none');
+  assert(evidence.recorded_at === null, '.agent/verification-evidence.json: recorded_at must be null when subject_type is none');
 } else {
+  assert(evidence.outcome === 'passed', '.agent/verification-evidence.json: outcome must be passed when verification evidence is recorded');
+  assert(isNonEmptyStringArray(evidence.verification_commands), '.agent/verification-evidence.json: verification_commands must be a non-empty array when verification evidence is recorded');
+  assert(isNonEmptyString(evidence.recorded_at) && !Number.isNaN(Date.parse(evidence.recorded_at)), '.agent/verification-evidence.json: recorded_at must be an ISO-8601 string when verification evidence is recorded');
+  if (currentHead) assert(evidence.head_sha === currentHead, '.agent/verification-evidence.json: head_sha must match current git HEAD when verification evidence is recorded');
+  if (evidence.subject_type === 'selected_slice') {
+    assert(isNonEmptyString(evidence.slice_id), '.agent/verification-evidence.json: slice_id must be a non-empty string when subject_type is selected_slice');
+    assert(isNonEmptyString(evidence.goal), '.agent/verification-evidence.json: goal must be a non-empty string when subject_type is selected_slice');
+    assert(isNonEmptyString(evidence.basis_commit), '.agent/verification-evidence.json: basis_commit must be a non-empty string when subject_type is selected_slice');
+  } else {
+    assert(evidence.subject_type === 'current_head', '.agent/verification-evidence.json: only current_head or selected_slice may carry recorded verification evidence');
+  }
+}
+
+if (!requiresExactHandoff) {
   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');
 }
@@ -2269,6 +2314,7 @@ async function scaffoldCompletionFiles(
 		},
 		{ 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.verificationEvidencePath, content: `${JSON.stringify(defaultVerificationEvidence(), null, 2)}\n` },
 		{ path: files.sliceHistoryPath, content: "" },
 		{ path: files.stopHistoryPath, content: "" },
 	];
@@ -2299,10 +2345,72 @@ function historyCounts(sliceHistory: JsonRecord[], stopHistory: JsonRecord[]) {
 	};
 }
 
+function sameStringArrays(left: string[], right: string[]): boolean {
+	return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+
+function hasOwnField(record: JsonRecord | undefined, field: string): boolean {
+	return !!record && Object.prototype.hasOwnProperty.call(record, field);
+}
+
+function activeCarriesExactHandoff(active: JsonRecord | undefined): boolean {
+	const status = asString(active?.status);
+	return status === "selected" || status === "in_progress" || status === "committed" || status === "done";
+}
+
+function activeSliceContractDriftFields(snapshot: CompletionStateSnapshot): string[] | undefined {
+	const active = snapshot.active;
+	const planSlice = snapshot.activeSlice;
+	const activeId = asString(active?.slice_id);
+	if (!activeId || !planSlice) return undefined;
+	const drift: string[] = [];
+	const expectPlanArrayMirror = (field: string) => {
+		if (!hasOwnField(planSlice, field) || !sameStringArrays(asStringArray(planSlice[field]), asStringArray(active?.[field]))) {
+			drift.push(field);
+		}
+	};
+	const expectPlanStringMirror = (field: string) => {
+		if (!hasOwnField(planSlice, field) || asString(planSlice[field]) !== asString(active?.[field])) {
+			drift.push(field);
+		}
+	};
+	const expectPlanNumberMirror = (field: string) => {
+		if (!hasOwnField(planSlice, field) || asNumber(planSlice[field]) !== asNumber(active?.[field])) {
+			drift.push(field);
+		}
+	};
+	if (asString(planSlice.slice_id) !== activeId) drift.push("slice_id");
+	if (asString(planSlice.goal) !== asString(active?.goal)) drift.push("goal");
+	if (!sameStringArrays(asStringArray(planSlice.contract_ids), asStringArray(active?.contract_ids))) drift.push("contract_ids");
+	if (!sameStringArrays(asStringArray(planSlice.acceptance_criteria), asStringArray(active?.acceptance_criteria))) drift.push("acceptance_criteria");
+	if (!sameStringArrays(asStringArray(planSlice.blocked_on), asStringArray(active?.blocked_on))) drift.push("blocked_on");
+	if (asNumber(planSlice.priority) !== asNumber(active?.priority)) drift.push("priority");
+	if (asString(planSlice.why_now) !== asString(active?.why_now)) drift.push("why_now");
+	expectPlanArrayMirror("implementation_surfaces");
+	expectPlanArrayMirror("verification_commands");
+	expectPlanArrayMirror("locked_notes");
+	expectPlanArrayMirror("must_fix_findings");
+	expectPlanStringMirror("basis_commit");
+	expectPlanArrayMirror("remaining_contract_ids_before");
+	expectPlanNumberMirror("release_blocker_count_before");
+	expectPlanNumberMirror("high_value_gap_count_before");
+	return Array.from(new Set(drift));
+}
+
+function activeSliceContractDriftSummary(snapshot: CompletionStateSnapshot): string {
+	const activeId = asString(snapshot.active?.slice_id);
+	if (!activeId) return "unknown";
+	if (!snapshot.activeSlice) return "slice_id (no matching plan slice)";
+	const drift = activeSliceContractDriftFields(snapshot);
+	return drift && drift.length > 0 ? drift.join(", ") : "none";
+}
+
 function activeSliceMatchesPlan(snapshot: CompletionStateSnapshot): "yes" | "no" | "unknown" {
 	const activeId = asString(snapshot.active?.slice_id);
 	if (!activeId) return "unknown";
-	return snapshot.activeSlice ? "yes" : "no";
+	const drift = activeSliceContractDriftFields(snapshot);
+	if (!snapshot.activeSlice || drift === undefined) return "no";
+	return drift.length === 0 ? "yes" : "no";
 }
 
 function handoffSnapshotState(active: JsonRecord | undefined): "present" | "missing_or_unclear" {
@@ -2322,7 +2430,7 @@ function handoffSnapshotState(active: JsonRecord | undefined): "present" | "miss
 		active?.release_blocker_count_before,
 		active?.high_value_gap_count_before,
 	];
-	return exactArrays.every((items) => items.length > 0) && required.every((value) => value !== undefined && value !== null)
+	return activeCarriesExactHandoff(active) && exactArrays.every((items) => items.length > 0) && required.every((value) => value !== undefined && value !== null)
 		? "present"
 		: "missing_or_unclear";
 }
@@ -2334,9 +2442,12 @@ function buildSystemReminder(snapshot: CompletionStateSnapshot, sliceHistory: Js
 	const activePriority = asNumber(snapshot.active?.priority);
 	const activeWhyNow = asString(snapshot.active?.why_now);
 	const nextRole = asString(snapshot.state?.next_mandatory_role);
+	const exactActiveContract = activeCarriesExactHandoff(snapshot.active);
+	const activeContractDrift = activeSliceContractDriftSummary(snapshot);
+	const evidence = verificationEvidenceContext(snapshot);
 	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.",
+		"Canonical truth lives in .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, .agent/stop-check-history.jsonl, and .agent/verification-evidence.json.",
 		`Mission anchor: ${asString(snapshot.state?.mission_anchor) ?? "(unknown)"}`,
 		`Task type: ${currentTaskType(snapshot) ?? "(missing)"}`,
 		`Evaluation profile: ${currentEvaluationProfile(snapshot) ?? "(missing)"}`,
@@ -2354,10 +2465,20 @@ function buildSystemReminder(snapshot: CompletionStateSnapshot, sliceHistory: Js
 		"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.",
 	];
+	if (exactActiveContract) {
+		lines.push("Selected/in-progress/committed/done .agent/active-slice.json is the canonical implementation contract.");
+		lines.push(`Active slice contract drift: ${activeContractDrift}`);
+	}
 	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(" | ")}`);
+	lines.push(`Verification evidence artifact: ${evidence.path} (${evidence.status})`);
+	if (evidence.subjectType) lines.push(`Verification evidence subject: ${evidence.subjectType}`);
+	if (evidence.outcome) lines.push(`Verification evidence outcome: ${evidence.outcome}`);
+	if (evidence.recordedAt) lines.push(`Verification evidence recorded_at: ${evidence.recordedAt}`);
+	if (evidence.verificationCommands.length > 0) lines.push(`Verification evidence commands: ${evidence.verificationCommands.join(" | ")}`);
+	lines.push(`Verification evidence summary: ${evidence.summary}`);
 	if (isRubricEvaluationRole(nextRole)) lines.push(buildEvaluationRoleReminderText(snapshot, nextRole));
 	return lines.join(" ");
 }
@@ -2374,26 +2495,43 @@ function buildPostCompactionDriverInstructions(snapshot: CompletionStateSnapshot
 	const verificationCommands = asStringArray(snapshot.active?.verification_commands);
 	const activePriority = asNumber(snapshot.active?.priority);
 	const activeWhyNow = asString(snapshot.active?.why_now);
+	const exactActiveContract = activeCarriesExactHandoff(snapshot.active);
+	const activeContractDrift = activeSliceContractDriftSummary(snapshot);
+	const evidence = verificationEvidenceContext(snapshot);
 	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.",
+		"Before taking any substantive action, re-read .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, .agent/stop-check-history.jsonl, and .agent/verification-evidence.json 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}`,
 		`Canonical active slice is currently: ${activeSliceId}`,
+		`Canonical verification evidence artifact is currently: ${evidence.path} (${evidence.status})`,
 		"Do not trust pre-compaction memory over canonical files.",
 		"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.",
 	];
+	if (exactActiveContract) {
+		lines.push("For selected/in-progress/committed/done slices, .agent/active-slice.json is the canonical implementation contract.");
+		lines.push(`Canonical active-slice contract drift is currently: ${activeContractDrift}`);
+	}
 	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 (evidence.subjectType) lines.push(`Canonical verification evidence subject is currently: ${evidence.subjectType}`);
+	if (evidence.outcome) lines.push(`Canonical verification evidence outcome is currently: ${evidence.outcome}`);
+	if (evidence.recordedAt) lines.push(`Canonical verification evidence recorded_at is currently: ${evidence.recordedAt}`);
+	if (evidence.headSha) lines.push(`Canonical verification evidence head_sha is currently: ${evidence.headSha}`);
+	if (evidence.basisCommit) lines.push(`Canonical verification evidence basis_commit is currently: ${evidence.basisCommit}`);
+	if (evidence.verificationCommands.length > 0) {
+		lines.push(`Canonical verification evidence commands are currently: ${evidence.verificationCommands.join(" | ")}`);
+	}
+	lines.push(`Canonical verification evidence summary is currently: ${evidence.summary}`);
 	if (isRubricEvaluationRole(nextRole)) lines.push(buildEvaluationRoleReminderText(snapshot, nextRole));
 	return lines.join(" ");
 }
@@ -2474,6 +2612,8 @@ function buildResumeCapsule(snapshot: CompletionStateSnapshot, sliceHistory: Jso
 	const implementationSurfaces = asStringArray(snapshot.active?.implementation_surfaces);
 	const verificationCommands = asStringArray(snapshot.active?.verification_commands);
 	const remainingBefore = asStringArray(snapshot.active?.remaining_contract_ids_before);
+	const activeContractDrift = activeSliceContractDriftSummary(snapshot);
+	const evidence = verificationEvidenceContext(snapshot);
 	const lines = [
 		"Authoritative completion resume capsule:",
 		"",
@@ -2490,9 +2630,23 @@ function buildResumeCapsule(snapshot: CompletionStateSnapshot, sliceHistory: Jso
 		`remaining_slice_count: ${remainingSliceCount(snapshot.plan)}`,
 		`remaining_stop_judges: ${asNumber(snapshot.state?.remaining_stop_judges) ?? "(unknown)"}`,
 		`active_slice_matches_plan: ${activeSliceMatchesPlan(snapshot)}`,
+		`active_slice_contract_drift_fields: ${activeContractDrift}`,
 		`implementer_handoff_snapshot: ${handoffSnapshotState(snapshot.active)}`,
 		`history_counts: reviewed=${history.reviewed}, audited=${history.audited}, accepted=${history.accepted}, reopened=${history.reopened}, judgments=${history.judgments}`,
 		"",
+		"verification_evidence:",
+		`- path: ${evidence.path}`,
+		`- status: ${evidence.status}`,
+		`- subject_type: ${evidence.subjectType ?? "(missing)"}`,
+		`- slice_id: ${evidence.sliceId ?? "(none)"}`,
+		`- contract_ids: ${evidence.contractIds.length > 0 ? evidence.contractIds.join(", ") : "(none)"}`,
+		`- outcome: ${evidence.outcome ?? "(missing)"}`,
+		`- recorded_at: ${evidence.recordedAt ?? "(missing)"}`,
+		`- head_sha: ${evidence.headSha ?? "(missing)"}`,
+		`- basis_commit: ${evidence.basisCommit ?? "(missing)"}`,
+		`- verification_commands: ${evidence.verificationCommands.length > 0 ? evidence.verificationCommands.join(" | ") : "(none)"}`,
+		`- summary: ${evidence.summary}`,
+		"",
 		"active_slice:",
 		`- slice_id: ${asString(snapshot.active?.slice_id) ?? asString(snapshot.activeSlice?.slice_id) ?? "(none)"}`,
 		`- status: ${asString(snapshot.active?.status) ?? asString(snapshot.activeSlice?.status) ?? "unknown"}`,
@@ -2517,14 +2671,16 @@ 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, 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.",
+		"- For selected/in-progress/committed/done slices, .agent/active-slice.json is the canonical implementation contract and the selected plan slice must mirror it exactly.",
+		"- Preserve exact slice_id, goal, contract_ids, acceptance criteria, blocked_on, priority, why_now, implementation surfaces, verification commands, locked notes, must-fix findings, basis_commit, and before-slice counters where still true.",
+		"- When populated, .agent/verification-evidence.json is the durable canonical verification record for the selected slice or current HEAD and should be consumed instead of temp-only artifacts or conversational summaries.",
+		"- After compaction, re-read .agent/state.json, .agent/plan.json, .agent/active-slice.json, .agent/slice-history.jsonl, .agent/stop-check-history.jsonl, and .agent/verification-evidence.json 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.",
-		"- Invoke completion-regrounder before continuing when active_slice_matches_plan is no or implementer_handoff_snapshot is missing_or_unclear.",
+		"- Invoke completion-regrounder before continuing when active_slice_matches_plan is no, active_slice_contract_drift_fields is not none, or implementer_handoff_snapshot is missing_or_unclear.",
 		"- If continuation_policy is continue, do not stop after a slice or ask whether to continue. Dispatch the next mandatory role directly.",
 		"- Only stop for the user when continuation_policy is await_user_input, blocked, paused, or done.",
-		"- If you are completion-implementer after compaction, resume from the canonical active-slice handoff instead of asking the user to resend the original caller payload.",
+		"- If you are completion-implementer after compaction, resume from the canonical active-slice implementation contract instead of asking the user to resend the original caller payload.",
 		"- Do not replace canonical .agent state with summary inference.",
 		"</completion-state>",
 	);
@@ -2949,7 +3105,7 @@ function formatInlineRunningText(theme: any, lines: string[], options?: { primar
 			continue;
 		}
 		if (line.startsWith("activity:")) {
-			text += theme.fg(line.includes("stalled") ? "warning" : "dim", line);
+			text += line.includes("stalled") ? theme.fg("warning", line) : line;
 			continue;
 		}
 		if (line === "recent tools:") {
@@ -2961,7 +3117,7 @@ function formatInlineRunningText(theme: any, lines: string[], options?: { primar
 			continue;
 		}
 		if (line.startsWith("elapsed:")) {
-			text += theme.fg("dim", line);
+			text += line;
 			continue;
 		}
 		if (line.startsWith("assistant:")) {
@@ -2973,7 +3129,7 @@ function formatInlineRunningText(theme: any, lines: string[], options?: { primar
 			continue;
 		}
 		if (line.startsWith("rationale:") || line.startsWith("state-delta:")) {
-			text += theme.fg("dim", line);
+			text += line;
 			continue;
 		}
 		text += theme.fg("muted", line);
@@ -3193,11 +3349,11 @@ function completionKickoff(
 			: 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\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.`;
+	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, .agent/active-slice.json, and .agent/verification-evidence.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- For selected, in-progress, committed, or done slices, treat .agent/active-slice.json as the canonical implementation contract and route to completion-regrounder if it drifts from the selected plan slice or the exact handoff is unclear.\n- Consume .agent/verification-evidence.json instead of temp-only verification summaries when it is populated.\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(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.`;
+	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, .agent/active-slice.json, and .agent/verification-evidence.json before acting.\n- If canonical state is missing, invalid, contradictory, stale, or ambiguous, route to completion-regrounder first.\n- For selected, in-progress, committed, or done slices, treat .agent/active-slice.json as the canonical implementation contract and route to completion-regrounder if it drifts from the selected plan slice or the exact handoff is unclear.\n- Consume .agent/verification-evidence.json instead of temp-only verification summaries when it is populated.\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) {
@@ -3621,13 +3777,11 @@ export default function completionExtension(pi: ExtensionAPI) {
 						);
 						return;
 					}
-					const decision = await confirmContextProposal(ctx, proposal, projectName, {
+					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "Start a completion workflow from the recent discussion?",
-						editorPrompt:
-							"Start a completion workflow from the recent discussion?\n\nEdit the proposed mission, scope, constraints, and acceptance details below.",
 					});
 					if (!decision) {
-						emitCommandText(ctx, "Cancelled recent-discussion workflow proposal", "info");
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled recent-discussion workflow proposal"), "info");
 						return;
 					}
 					goal = decision.goalText;
@@ -3635,14 +3789,12 @@ export default function completionExtension(pi: ExtensionAPI) {
 					kickoffAnalysis = decision.analysis;
 				} else {
 					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-					const decision = await confirmContextProposal(ctx, proposal, projectName, {
+					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "Start a completion workflow from this goal?",
 						nonInteractiveBehavior: "accept",
-						editorPrompt:
-							"Start a completion workflow from this goal?\n\nEdit the proposed mission, scope, constraints, and acceptance details below.",
 					});
 					if (!decision) {
-						emitCommandText(ctx, "Cancelled workflow startup proposal", "info");
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled workflow startup proposal"), "info");
 						return;
 					}
 					goal = decision.goalText;
@@ -3681,13 +3833,11 @@ export default function completionExtension(pi: ExtensionAPI) {
 						);
 						return;
 					}
-					const decision = await confirmContextProposal(ctx, proposal, projectName, {
+					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "The previous completion workflow is done. Start the next workflow round from the recent discussion?",
-						editorPrompt:
-							"The previous completion workflow is done. Start the next workflow round from the recent discussion?\n\nEdit the proposed mission, scope, constraints, and acceptance details below.",
 					});
 					if (!decision) {
-						emitCommandText(ctx, "Cancelled next workflow round proposal", "info");
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal"), "info");
 						return;
 					}
 					goal = decision.goalText;
@@ -3710,7 +3860,9 @@ export default function completionExtension(pi: ExtensionAPI) {
 						current_phase: asString(snapshot.state?.current_phase) ?? null,
 						next_mandatory_role: asString(snapshot.state?.next_mandatory_role) ?? null,
 					});
-					await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, resumePrompt, "resume");
+					const resumeKind =
+						shouldTestAutoContinueOnSessionStart() && completionTestAutoContinuePromptPath() ? "auto-resume" : "resume";
+					await queueCompletionDriverPrompt(pi, ctx, rootKey, fingerprint, resumePrompt, resumeKind);
 					return;
 				}
 			}
@@ -3719,14 +3871,12 @@ export default function completionExtension(pi: ExtensionAPI) {
 				if (workflowDone) {
 					const projectName = path.basename(snapshot.files.root);
 					const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-					const decision = await confirmContextProposal(ctx, proposal, projectName, {
+					const decision = await confirmContextProposal(ctx, proposal, {
 						title: "Start the next workflow round from this goal?",
 						nonInteractiveBehavior: "accept",
-						editorPrompt:
-							"Start the next workflow round from this goal?\n\nEdit the proposed mission, scope, constraints, and acceptance details below.",
 					});
 					if (!decision) {
-						emitCommandText(ctx, "Cancelled next workflow round proposal", "info");
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled next workflow round proposal"), "info");
 						return;
 					}
 					goal = decision.goalText;
@@ -3738,7 +3888,7 @@ export default function completionExtension(pi: ExtensionAPI) {
 				} else {
 					const decision = await confirmExistingWorkflowGoal(ctx, snapshot, goal);
 					if (!decision) {
-						emitCommandText(ctx, "Cancelled existing workflow confirmation", "info");
+						emitCommandText(ctx, buildCookCancellationMessage("Cancelled existing workflow confirmation"), "info");
 						return;
 					}
 					kickoffIntent = decision.action;
@@ -3746,14 +3896,12 @@ export default function completionExtension(pi: ExtensionAPI) {
 					if (decision.action === "refocus") {
 						const projectName = path.basename(snapshot.files.root);
 						const proposal = await buildGoalAnchoredContextProposal(ctx, goal, projectName);
-						const proposalDecision = await confirmContextProposal(ctx, proposal, projectName, {
+						const proposalDecision = await confirmContextProposal(ctx, proposal, {
 							title: "Start the replacement workflow from this goal?",
 							nonInteractiveBehavior: "accept",
-							editorPrompt:
-								"Start the replacement workflow from this goal?\n\nEdit the proposed mission, scope, constraints, and acceptance details below.",
 						});
 						if (!proposalDecision) {
-							emitCommandText(ctx, "Cancelled replacement workflow proposal", "info");
+							emitCommandText(ctx, buildCookCancellationMessage("Cancelled replacement workflow proposal"), "info");
 							return;
 						}
 						goal = proposalDecision.goalText;