immune-brain 3.6.6 → 3.6.8

package/plugins/immune-brain/runtime/claude/mcp_server.ts

@@ -25,8 +25,10 @@ export const TOOLS = [
 	{ name: "request_authorization", description: "Apply exact literal-user authorization.", privileged: true },
 	{ name: "approve_breaking_intent_revision", description: "Approve a breaking TaskIntent revision.", privileged: true },
 	{ name: "stop", description: "Stop the active task with literal-user authority.", privileged: true },
+	{ name: "start_unattended_batch", description: "Start an unattended serial batch run for an Initiative after native confirmation.", privileged: true },
 	{ name: "repair_authority_state", description: "Repair a proven recoverable stale backend claim.", privileged: false },
 	{ name: "resolve_finding", description: "Resolve one open blocking or advisory finding whose cause is fixed and verified.", privileged: false },
+	{ name: "refute_finding", description: "Refute one open finding by binding the fresh passing QA attestation that contradicts it.", privileged: false },
 ] as const;
 
 export function listMcpTools() {
@@ -36,17 +38,26 @@ export function listMcpTools() {
 		inputSchema: {
 			type: "object",
 			properties: {
-				task_id: { type: "string" },
-				...(tool.name === "approve_breaking_intent_revision" ? { next_intent: { type: "object" } } : {}),
-				...(tool.name === "stop" ? { reason: { type: "string" } } : {}),
-				...(tool.name === "submit_review" ? { verdict: { type: "object" } } : {}),
-				...(tool.name === "resolve_finding" ? { finding_id: { type: "string" } } : {}),
+				...(tool.name === "start_unattended_batch"
+					? { initiative_slug: { type: "string" } }
+					: {
+						task_id: { type: "string" },
+						...(tool.name === "approve_breaking_intent_revision" ? { next_intent: { type: "object" } } : {}),
+						...(tool.name === "stop" ? { reason: { type: "string" } } : {}),
+						...(tool.name === "submit_review" ? { verdict: { type: "object" } } : {}),
+						...(tool.name === "resolve_finding" ? { finding_id: { type: "string" } } : {}),
+						...(tool.name === "refute_finding" ? { finding_id: { type: "string" }, attestation_id: { type: "string" } } : {}),
+					}),
 			},
-			required: tool.name === "submit_review"
-				? ["task_id", "verdict"]
-				: tool.name === "resolve_finding"
-					? ["task_id", "finding_id"]
-					: ["task_id"],
+			required: tool.name === "start_unattended_batch"
+				? ["initiative_slug"]
+				: tool.name === "submit_review"
+					? ["task_id", "verdict"]
+					: tool.name === "resolve_finding"
+						? ["task_id", "finding_id"]
+						: tool.name === "refute_finding"
+							? ["task_id", "finding_id", "attestation_id"]
+							: ["task_id"],
 		},
 		annotations: tool.privileged ? privilegedAnnotations() : { readOnlyHint: tool.name === "status" },
 	}));
@@ -63,6 +74,9 @@ export interface McpRuntimeOptions {
 	host?: ClaudeReviewHost;
 	interactive?: boolean;
 	requestConfirmation?: NativeConfirmationPort;
+	batchKernel?: Partial<import("../unattended/batch_runner").BatchRunnerKernelPort>;
+	batchGit?: import("../unattended/batch_git").BatchRunnerGitPort;
+	readInitiative?: import("../unattended/types").InitiativeObservationReader;
 }
 
 export function createMcpRuntime(options: McpRuntimeOptions = {}) {
@@ -74,6 +88,9 @@ export function createMcpRuntime(options: McpRuntimeOptions = {}) {
 		ports: options.ports,
 		interactive: options.interactive,
 		requestConfirmation: options.requestConfirmation,
+		batchKernel: options.batchKernel,
+		batchGit: options.batchGit,
+		readInitiative: options.readInitiative,
 	});
 	// Trusted Host evidence negotiated on this JSON-RPC connection. Absent
 	// handshake evidence means unversioned and non-interactive: fail closed.
@@ -95,6 +112,26 @@ export function createMcpRuntime(options: McpRuntimeOptions = {}) {
 		},
 		sessionInteractive: () => negotiatedInteractive,
 		async callTool(name: string, args: Record<string, unknown>, meta: Partial<ToolMeta> = {}) {
+			if (name === "start_unattended_batch") {
+				const initiativeSlug = String(args.initiative_slug ?? "");
+				if (!initiativeSlug) throw new Error("initiative_slug is required");
+				if ("native_decision" in args) throw new Error("native_decision cannot be supplied in tool arguments");
+				if (!negotiatedVersion) throw new NativeAuthorityError("unsupported_host", "Claude Code version is unavailable");
+				if (!negotiatedInteractive) {
+					throw new NativeAuthorityError("unsupported_host", "interactive MCP elicitation is unavailable");
+				}
+				const probe = probeHost(options.env ?? process.env, process.platform, negotiatedVersion);
+				if (!probe.ok) throw new NativeAuthorityError("unsupported_host", probe.reason);
+				const toolMeta: ToolMeta = {
+					sessionId: meta.sessionId ?? connectionId,
+					toolCallId: meta.toolCallId ?? `call-${name}`,
+					taskId: initiativeSlug,
+					initiativeSlug,
+					interactive: meta.interactive ?? options.interactive ?? negotiatedInteractive,
+					signal: meta.signal,
+				};
+				return runtime.startUnattendedBatch(initiativeSlug, toolMeta);
+			}
 			const taskId = String(args.task_id ?? "");
 			if (!taskId) throw new Error("task_id is required");
 			if ("native_decision" in args) throw new Error("native_decision cannot be supplied in tool arguments");
@@ -132,6 +169,13 @@ export function createMcpRuntime(options: McpRuntimeOptions = {}) {
 				if (typeof args.finding_id !== "string" || !args.finding_id) throw new Error("finding_id is required");
 				return runtime.resolveFinding(taskId, args.finding_id);
 			}
+			if (name === "refute_finding") {
+				// Structural only, exactly like resolve_finding: the reducer owns
+				// which findings may be refuted and with which evidence.
+				if (typeof args.finding_id !== "string" || !args.finding_id) throw new Error("finding_id is required");
+				if (typeof args.attestation_id !== "string" || !args.attestation_id) throw new Error("attestation_id is required");
+				return runtime.refuteFinding(taskId, args.finding_id, args.attestation_id);
+			}
 			if (name === "request_authorization" || name === "approve_breaking_intent_revision" || name === "stop" || name === "repair_authority_state") {
 				return runtime.authorize(taskId, name, toolMeta, args);
 			}
@@ -309,6 +353,24 @@ async function writeReply(output: Writable, reply: JsonRpc): Promise<void> {
 }
 
 export function elicitationParams(input: NativeConfirmationInput) {
+	if (input.operation === "start_unattended_batch") {
+		const b = input.batchDetails;
+		const details = [
+			`Operation: start_unattended_batch`,
+			`Initiative: ${input.initiativeSlug ?? b?.initiative_slug}`,
+			b?.batch_branch ? `Batch branch: ${b.batch_branch}` : null,
+			input.planDigest ? `Plan digest: ${input.planDigest}` : null,
+			b?.children ? `Ordered children (${b.children.length}):\n${b.children.map((c) => `  - ${c.task_id} (${c.slice_id}) [risk: ${c.risk ?? "unknown"}]`).join("\n")}` : null,
+			b?.excluded && b.excluded.length > 0 ? `Excluded children (${b.excluded.length}):\n${b.excluded.map((e) => `  - ${e.task_id} (${e.slice_id}): ${e.reason}`).join("\n")}` : null,
+			b?.budget ? `Budget: max_children=${b.budget.max_children}, deadline_at=${b.budget.deadline_at}, qa_failure_limit=${b.budget.qa_failure_limit}` : null,
+			b?.expires_at ? `Expires at: ${b.expires_at}` : null,
+		].filter(Boolean);
+		return {
+			mode: "form",
+			message: `Authorize this unattended batch run for ${input.initiativeSlug}?\n\n${details.join("\n")}`,
+			requestedSchema: { type: "object", properties: {} },
+		};
+	}
 	const details = [
 		`Operation: ${input.operation}`,
 		`Task: ${input.taskId}`,

package/plugins/immune-brain/runtime/kernel/canary_application.ts

@@ -49,6 +49,7 @@ export type CanaryOperation =
 	| { op: "freeze_artifacts"; actor_id: string }
 	| { op: "record_finding"; finding: Omit<TaskFinding, "status" | "source" | "review_round">; actor_id: string }
 	| { op: "resolve_finding"; finding_id: string; actor_id: string }
+	| { op: "refute_finding"; finding_id: string; attestation_id: string; actor_id: string }
 	| { op: "request_rework"; capability: object; findings: TaskFinding[]; actor_id: string }
 	| { op: "record_approval"; capability: object; approval: TaskApprovalV2; actor_id: string }
 	| { op: "revise_intent"; next_intent: TaskIntentV1; actor_id: string }
@@ -367,6 +368,14 @@ export function createCanaryApplication(
 			case "resolve_finding":
 				action = { ...base, type: "resolve_finding", finding_id: operation.finding_id };
 				break;
+			case "refute_finding":
+				action = {
+					...base,
+					type: "refute_finding",
+					finding_id: operation.finding_id,
+					attestation_id: operation.attestation_id,
+				};
+				break;
 			case "request_rework":
 				capability = operation.capability;
 				action = { ...base, type: "request_rework", findings: operation.findings };

package/plugins/immune-brain/runtime/kernel/completion.ts

@@ -8,6 +8,7 @@ import type {
 	TaskRecord,
 } from "./types";
 import { assertKernelInvariantsV3, KernelInvariantError } from "./validation";
+import { refutationIsLive } from "./refutation";
 
 const REQUIRED_ATTESTATIONS: Record<TaskIntentV1["risk"], ApprovalKind[]> = {
 	routine: ["qa"],
@@ -137,8 +138,25 @@ export function completionDecision(
 		.filter((item) => repeatedActors.has(item.actor_id))
 		.map((item) => item.id);
 
+	// A refutation is live only while its bound QA attestation is still fresh
+	// for this diff and intent hash. When it goes stale the refuted finding
+	// counts as blocking again; nothing stored is rewritten by that
+	// invalidation, so the append-only invariant survives. The identity is the
+	// one `freshAttestations` filters on, including the caller's current intent
+	// hash, so a drifted intent revives the gate with the attestation.
+	const refutationState = {
+		intent_revision: intent.revision,
+		intent_content_hash: currentIntentContentHash,
+		diff_hash: currentDiffHash,
+	};
 	const blockingFindingIds = record.findings
-		.filter((item) => item.status === "open" && item.kind === "blocking")
+		.filter(
+			(item) =>
+				item.kind === "blocking" &&
+				(item.status === "open" ||
+					(item.status === "refuted" &&
+						!refutationIsLive(item, record.attestations, refutationState))),
+		)
 		.map((item) => item.id);
 	const unresolvedUserDecisionIds = record.findings
 		.filter((item) => item.status === "open" && item.kind === "unresolved_user_decision")

package/plugins/immune-brain/runtime/kernel/reducer.ts

@@ -4,6 +4,7 @@
 
 import { createHash } from "node:crypto";
 import { completionDecision } from "./completion";
+import { anchorForEvidence, isFreshPassingQaAttestation, refutationIdentity, refutationIsLive } from "./refutation";
 import {
 	REDUCED_MUTATION_BRAND,
 	TASK_RECORD_CONTRACT_V4,
@@ -193,15 +194,35 @@ function hasPrivilegedKind(action: TaskAction): boolean {
  * set and applied to another.
  */
 export function findingsDigestV2(findings: TaskFinding[]): string {
+	// Anchor and evidence are included only when the finding actually carries
+	// them, so a pre-extension findings set keeps its historical bytes while a
+	// capability minted over one anchor set cannot be spent on another.
 	const normalized = findings.map((finding) => ({
 		id: finding.id,
 		kind: finding.kind,
 		acceptance_id: finding.acceptance_id,
 		summary: finding.summary,
+		...(finding.anchor !== undefined ? { anchor: finding.anchor ?? null } : {}),
+		...(finding.evidence !== undefined ? { evidence: finding.evidence ?? null } : {}),
 	}));
 	return `sha256:${createHash("sha256").update(stableJson(normalized)).digest("hex")}`;
 }
 
+/**
+ * Two findings share an acceptance boundary when they name the same
+ * acceptance, or when neither does and their review evidence names the same
+ * violated reference. Null boundaries without comparable evidence are not
+ * shared, so a second-round finding can no longer park the task by accident.
+ */
+function sharesAcceptanceBoundary(left: TaskFinding, right: TaskFinding): boolean {
+	if (left.acceptance_id !== null && right.acceptance_id !== null)
+		return left.acceptance_id === right.acceptance_id;
+	if (left.acceptance_id !== null || right.acceptance_id !== null) return false;
+	const leftRef = left.evidence?.violated.ref ?? null;
+	const rightRef = right.evidence?.violated.ref ?? null;
+	return leftRef !== null && leftRef === rightRef;
+}
+
 export function reduceTask(
 	recordRaw: TaskRecord,
 	actionRaw: TaskAction,
@@ -311,10 +332,81 @@ export function reduceTask(
 				throw new KernelInvariantError([
 					`finding ${action.finding_id} is already resolved`,
 				]);
+			// A live refutation already suppresses the finding, so resolving it
+			// would make that suppression permanent. Only a refutation whose bound
+			// evidence went stale may still be resolved.
+			if (
+				finding.status === "refuted" &&
+				refutationIsLive(
+					finding,
+					record.attestations,
+					refutationIdentity(record, action.diff_hash),
+				)
+			)
+				throw new KernelInvariantError([
+					`finding ${action.finding_id} is still refuted by live counterevidence`,
+				]);
 			finding.status = "resolved";
 			appendHistory(record, action, from, action.finding_id, authorityAudit);
 			break;
 		}
+		case "refute_finding": {
+			if (record.lifecycle !== "active")
+				throw new KernelInvariantError([
+					`cannot refute findings while lifecycle is ${record.lifecycle}`,
+				]);
+			const finding = record.findings.find(
+				(item) => item.id === action.finding_id,
+			);
+			if (!finding)
+				throw new KernelInvariantError([
+					`finding ${action.finding_id} does not exist`,
+				]);
+			if (finding.kind === "unresolved_user_decision" || finding.kind === "replan_required")
+				throw new KernelInvariantError([
+					"refute_finding cannot refute a user decision or replan boundary",
+				]);
+			if (finding.status === "resolved")
+				throw new KernelInvariantError([
+					`finding ${action.finding_id} is already resolved`,
+				]);
+			if (!finding.acceptance_id)
+				throw new KernelInvariantError([
+					"refute_finding requires a finding bound to an acceptance id",
+				]);
+			if (
+				finding.status === "refuted" &&
+				refutationIsLive(
+					finding,
+					record.attestations,
+					refutationIdentity(record, action.diff_hash),
+				)
+			)
+				throw new KernelInvariantError([
+					`finding ${action.finding_id} is already refuted by live counterevidence`,
+				]);
+			// The actor cannot assert a refutation; it can only bind a QA
+			// attestation the Kernel already validated as fresh and passing for
+			// this acceptance. A stale binding is rebindable with new evidence,
+			// which is how a refutation is renewed after a diff or intent change.
+			if (
+				!isFreshPassingQaAttestation(
+					record.attestations.find((item) => item.id === action.attestation_id),
+					finding.acceptance_id,
+					refutationIdentity(record, action.diff_hash),
+				)
+			)
+				throw new KernelInvariantError([
+					`refute_finding requires a fresh passing QA attestation covering ${finding.acceptance_id ?? "null"}`,
+				]);
+			finding.status = "refuted";
+			finding.counterevidence = {
+				attestation_id: action.attestation_id,
+				acceptance_id: finding.acceptance_id,
+			};
+			appendHistory(record, action, from, action.finding_id, authorityAudit);
+			break;
+		}
 		case "record_approval": {
 			if (record.lifecycle !== "active" || record.artifact_state !== "frozen")
 				throw new KernelInvariantError([
@@ -452,32 +544,94 @@ export function reduceTask(
 					"request_rework requires review, qa, or user authority",
 				]);
 			const round = reviewRound(record);
-			const hasPriorBlockingReviewRework = record.findings.some(
+			// An anchor is authority: it decides whether this claim inherits an
+			// existing refutation. The Kernel recomputes it from the finding's own
+			// evidence, so a caller cannot bind one claim's identity to another
+			// claim's provenance.
+			for (const finding of action.findings) {
+				const anchor = finding.anchor ?? null;
+				const evidence = finding.evidence ?? null;
+				if ((anchor === null) !== (evidence === null))
+					throw new KernelInvariantError([
+						`finding ${finding.id} must carry anchor and evidence together`,
+					]);
+				if (evidence && anchor !== anchorForEvidence(evidence))
+					throw new KernelInvariantError([
+						`finding ${finding.id} anchor must equal the digest of its evidence`,
+					]);
+				// Only a Review rework carries reviewer provenance; a QA or user
+				// rework that does would be a caller asserting review identity.
+				if (anchor !== null && authorityAudit.authority_kind !== "review")
+					throw new KernelInvariantError([
+						`${authorityAudit.authority_kind} rework cannot carry review provenance`,
+					]);
+			}
+			const identity = refutationIdentity(record, action.diff_hash);
+			// A prior finding that is still refuted by live evidence is not an
+			// outstanding dispute, so a new claim on its boundary is not a repeat
+			// offence. Once its evidence goes stale it blocks again and counts.
+			const priorBlockingReviewFindings = record.findings.filter(
 				(finding) =>
 					finding.source === "review" &&
 					finding.kind === "blocking" &&
-					finding.review_round !== null,
+					finding.review_round !== null &&
+					!(
+						finding.status === "refuted" &&
+						refutationIsLive(finding, record.attestations, identity)
+					),
 			);
+			// Anchor reconciliation: a new Review finding whose anchor matches a
+			// Review finding that is still live-refuted is admitted as refuted with
+			// the inherited counterevidence binding, for blocking and advisory
+			// claims alike. The claim's identity is the anchor, so the inherited
+			// binding keeps the acceptance its QA evidence was actually proved on.
+			// A refutation whose evidence went stale no longer suppresses anything,
+			// so the same claim is admitted as open and blocks again.
+			const admissions = action.findings.map((finding) => {
+				const inherited =
+					finding.anchor != null
+						? record.findings.find(
+								(prior) =>
+									prior.source === "review" &&
+									prior.status === "refuted" &&
+									prior.anchor === finding.anchor &&
+									refutationIsLive(prior, record.attestations, identity),
+							)
+						: undefined;
+				return { finding, inherited };
+			});
+			const disputed = admissions.find(
+				({ finding, inherited }) =>
+					finding.kind === "blocking" &&
+					inherited === undefined &&
+					priorBlockingReviewFindings.some((prior) =>
+						sharesAcceptanceBoundary(finding, prior),
+					),
+			)?.finding;
 			const parkForReplan =
-				authorityAudit.authority_kind === "review" &&
-				hasPriorBlockingReviewRework &&
-				action.findings.some((finding) => finding.kind === "blocking");
+				authorityAudit.authority_kind === "review" && disputed !== undefined;
 			if (!parkForReplan) {
 				record.artifact_state = "active";
 				record.intent_ref.path = `docs/plans/${record.task_id}.intent.json`;
 			}
 			const findingIds = new Set(record.findings.map((item) => item.id));
-			for (const finding of action.findings) {
+			for (const { finding, inherited } of admissions) {
 				if (findingIds.has(finding.id))
 					throw new KernelInvariantError([
 						`findings contains duplicate id ${finding.id}`,
 					]);
 				findingIds.add(finding.id);
 				record.findings.push({
-					...finding,
-					status: "open",
+					id: finding.id,
+					kind: finding.kind,
+					status: inherited ? "refuted" : "open",
+					acceptance_id: finding.acceptance_id,
 					source: authorityAudit.authority_kind === "review" ? "review" : "execution",
 					review_round: authorityAudit.authority_kind === "review" ? round : null,
+					summary: finding.summary,
+					...(finding.anchor !== undefined ? { anchor: finding.anchor } : {}),
+					...(finding.evidence !== undefined ? { evidence: finding.evidence } : {}),
+					counterevidence: inherited ? { ...inherited.counterevidence! } : null,
 				});
 			}
 			if (
@@ -486,9 +640,6 @@ export function reduceTask(
 					(item) => item.status === "open" && item.kind === "replan_required",
 				)
 			) {
-				const disputed =
-					action.findings.find((item: TaskFinding) => item.kind === "blocking") ??
-					action.findings[0];
 				const boundary = {
 					id: `${action.event_id}:replan-required`,
 					kind: "replan_required" as const,

package/plugins/immune-brain/runtime/kernel/refutation.ts

@@ -0,0 +1,82 @@
+// Derived refutation liveness. One predicate shared by the reducer, the
+// completion projection and the TaskRecord update invariants, so the rule that
+// decides whether a refuted finding still blocks cannot drift between them.
+
+import { createHash } from "node:crypto";
+import { stableStringify } from "../canonical_json";
+import type { FindingEvidence, TaskAttestationV3, TaskFinding } from "./types";
+
+export interface RefutationIdentity {
+	intent_revision: number;
+	intent_content_hash: string;
+	diff_hash: string;
+}
+
+export function refutationIdentity(
+	record: {
+		intent_snapshot: { revision: number };
+		intent_ref: { content_hash: string };
+	},
+	diffHash: string,
+): RefutationIdentity {
+	return {
+		intent_revision: record.intent_snapshot.revision,
+		intent_content_hash: record.intent_ref.content_hash,
+		diff_hash: diffHash,
+	};
+}
+
+/**
+ * Kernel-side derivation of a review claim's anchor. The Host parses the
+ * reviewer's prose into evidence, but the digest that decides refutation
+ * inheritance is recomputed from that evidence, so a caller can never bind one
+ * claim's identity to another claim's bytes.
+ */
+export function anchorForEvidence(evidence: FindingEvidence): string {
+	return `sha256:${createHash("sha256")
+		.update(
+			stableStringify({
+				violated: evidence.violated,
+				caller_chain: evidence.caller_chain,
+			}),
+		)
+		.digest("hex")}`;
+}
+
+/**
+ * Freshness of one QA attestation for one acceptance: the single rule shared
+ * by the refutation predicate and the `refute_finding` transition guard.
+ */
+export function isFreshPassingQaAttestation(
+	attestation: TaskAttestationV3 | undefined,
+	acceptanceId: string,
+	identity: RefutationIdentity,
+): boolean {
+	if (!attestation || attestation.kind !== "qa") return false;
+	if (attestation.task_revision !== identity.intent_revision) return false;
+	if (attestation.intent_content_hash !== identity.intent_content_hash) return false;
+	if (attestation.diff_hash !== identity.diff_hash) return false;
+	return attestation.acceptance_results.some(
+		(result) => result.acceptance_id === acceptanceId && result.status === "passed",
+	);
+}
+
+/**
+ * A refutation is live only while the QA attestation it bound is still fresh
+ * for the record's current intent revision, intent hash and diff identity, and
+ * still passes the acceptance it was bound to. Liveness is derived here and
+ * never stored, so an invalidated refutation counts as blocking again.
+ */
+export function refutationIsLive(
+	finding: TaskFinding,
+	attestations: readonly TaskAttestationV3[],
+	identity: RefutationIdentity,
+): boolean {
+	const counterevidence = finding.counterevidence ?? null;
+	if (!counterevidence?.attestation_id || !counterevidence.acceptance_id) return false;
+	return isFreshPassingQaAttestation(
+		attestations.find((item) => item.id === counterevidence.attestation_id),
+		counterevidence.acceptance_id,
+		identity,
+	);
+}

package/plugins/immune-brain/runtime/kernel/types.ts

@@ -16,9 +16,24 @@ export type FindingKind =
 	| "advisory"
 	| "unresolved_user_decision"
 	| "replan_required";
-export type FindingStatus = "open" | "resolved";
+export type FindingStatus = "open" | "resolved" | "refuted";
 export type FindingSource = "execution" | "review" | "kernel" | "migration";
 
+/** Machine-checkable provenance a Review finding must carry at the verdict boundary. */
+export interface FindingEvidence {
+	trigger: string;
+	caller_chain: string[];
+	violated: {
+		kind: "acceptance" | "security_boundary";
+		ref: string;
+	};
+}
+
+export interface FindingCounterevidence {
+	attestation_id: string;
+	acceptance_id: string;
+}
+
 export interface TaskFinding {
 	id: string;
 	kind: FindingKind;
@@ -27,6 +42,19 @@ export interface TaskFinding {
 	source: FindingSource;
 	review_round: number | null;
 	summary: string;
+	/**
+	 * Additive v4 fields. Absent on records written before this contract
+	 * extension, so the TaskRecord contract is not bumped; `parseFinding`
+	 * normalizes them to null.
+	 *
+	 * `anchor` identifies the claim (sha256 over violated + caller_chain),
+	 * `evidence` is the reviewer-supplied provenance that produced it, and
+	 * `counterevidence` binds a refutation to the Kernel-validated QA
+	 * attestation that contradicted the claim.
+	 */
+	anchor?: string | null;
+	evidence?: FindingEvidence | null;
+	counterevidence?: FindingCounterevidence | null;
 }
 
 export type ApprovalKind = "review" | "qa" | "user";
@@ -283,6 +311,11 @@ export interface TaskActionBase {
 export type TaskAction =
 	| (TaskActionBase & { type: "record_finding"; finding: TaskFinding })
 	| (TaskActionBase & { type: "resolve_finding"; finding_id: string })
+	| (TaskActionBase & {
+			type: "refute_finding";
+			finding_id: string;
+			attestation_id: string;
+	  })
 	| (TaskActionBase & { type: "record_approval"; approval: TaskApprovalV2 })
 	| (TaskActionBase & {
 			type: "revise_intent";