@fitlab-ai/agent-infra 0.9.10 → 0.9.12

package/lib/task/review-artifacts.ts

@@ -18,6 +18,21 @@ type ReviewSummaryErrorCode =
   | 'REVIEW_SUMMARY_NOT_FOUND'
   | 'REVIEW_SUMMARY_PLACEHOLDER_INVALID'
   | 'REVIEW_SUMMARY_COUNT_MISMATCH';
+type VerdictSemanticErrorCode =
+  | 'REVIEW_VERDICT_FINDING_MISMATCH'
+  | 'REVIEW_FINDING_COUNTS_NOT_FINALIZED';
+type CanonicalVerdictResult =
+  | { ok: true; verdict: ReviewVerdict }
+  | { ok: false; verdict: null; code: VerdictSemanticErrorCode; message: string };
+type PathVerdictErrorCode =
+  | 'REVIEW_ARTIFACT_NOT_FOUND'
+  | 'REVIEW_ARTIFACT_READ_FAILED'
+  | 'REVIEW_SUMMARY_NOT_FOUND'
+  | 'REVIEW_SUMMARY_PLACEHOLDER_INVALID'
+  | VerdictSemanticErrorCode;
+type PathVerdictResult =
+  | { ok: true; verdict: ReviewVerdict }
+  | { ok: false; verdict: null; code: PathVerdictErrorCode; message: string };
 type ReviewSummaryParseResult =
   | { ok: true; summary: ReviewSummary; findingsStart: number; findingsEnd: number }
   | { ok: false; code: ReviewSummaryErrorCode; message: string };
@@ -203,28 +218,46 @@ function finalizeReviewSummaryContent(
   };
 }
 
-function parseVerdict(reviewPath: string):
-  | { ok: true; verdict: 'Approved' | 'Approved-with-issues' | 'Changes Requested' | 'Rejected' }
-  | { ok: false; verdict: null; message: string } {
+function resolveCanonicalVerdict(summary: ReviewSummary): CanonicalVerdictResult {
+  if (summary.counts === null) {
+    return {
+      ok: false,
+      verdict: null,
+      code: 'REVIEW_FINDING_COUNTS_NOT_FINALIZED',
+      message: 'review summary finding counts are not finalized'
+    };
+  }
+  if (summary.verdict === 'Approved' && !equalCounts(summary.counts, { blocker: 0, major: 0, minor: 0 })) {
+    return {
+      ok: false,
+      verdict: null,
+      code: 'REVIEW_VERDICT_FINDING_MISMATCH',
+      message: 'Approved verdict requires zero finalized findings'
+    };
+  }
+  return { ok: true, verdict: summary.verdict };
+}
+
+function parseVerdict(reviewPath: string): PathVerdictResult {
   if (!fs.existsSync(reviewPath)) {
-    return { ok: false, verdict: null, message: `Review artifact not found: ${path.basename(reviewPath)}` };
+    return { ok: false, verdict: null, code: 'REVIEW_ARTIFACT_NOT_FOUND', message: `Review artifact not found: ${path.basename(reviewPath)}` };
+  }
+  let content: string;
+  try {
+    content = fs.readFileSync(reviewPath, 'utf8');
+  } catch (error) {
+    return { ok: false, verdict: null, code: 'REVIEW_ARTIFACT_READ_FAILED', message: `Review artifact could not be read: ${String(error)}` };
   }
-  const parsed = parseReviewSummary(fs.readFileSync(reviewPath, 'utf8'));
+  const parsed = parseReviewSummary(content);
   if (!parsed.ok) {
     return {
       ok: false,
       verdict: null,
+      code: parsed.code === 'REVIEW_SUMMARY_PLACEHOLDER_INVALID' ? parsed.code : 'REVIEW_SUMMARY_NOT_FOUND',
       message: `cannot parse review summary in ${path.basename(reviewPath)}: ${parsed.message}`
     };
   }
-  const { verdict, counts } = parsed.summary;
-  if (verdict !== 'Approved') return { ok: true, verdict };
-  return {
-    ok: true,
-    verdict: counts && equalCounts(counts, { blocker: 0, major: 0, minor: 0 })
-      ? 'Approved'
-      : 'Approved-with-issues'
-  };
+  return resolveCanonicalVerdict(parsed.summary);
 }
 
 export {
@@ -236,13 +269,18 @@ export {
   maxRound,
   normalizeVerdict,
   parseReviewSummary,
-  parseVerdict
+  parseVerdict,
+  resolveCanonicalVerdict
 };
 export type {
+  CanonicalVerdictResult,
+  PathVerdictErrorCode,
+  PathVerdictResult,
   ReviewFindingCounts,
   ReviewSummary,
   ReviewSummaryErrorCode,
   ReviewSummaryFinalizeResult,
   ReviewSummaryParseResult,
-  ReviewVerdict
+  ReviewVerdict,
+  VerdictSemanticErrorCode
 };

package/lib/task/review-finalization.ts

@@ -2,11 +2,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
-import { locateActivityLog, pairEntries } from './activity-log.ts';
+import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
 import { parseArtifactName, validateCompletedArtifact } from './artifact-lifecycle.ts';
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import type { LedgerStageStatus, ReviewStage } from './ledger.ts';
 import { finalizeReviewSummaryContent } from './review-artifacts.ts';
+import { inspectDecisionDetailDuplicates } from './decision-details.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { validateLifecycleExecution } from './lifecycle-execution.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
@@ -25,6 +26,7 @@ type ReviewFinalizationErrorCode =
   | 'REVIEW_SUMMARY_NOT_FOUND'
   | 'REVIEW_SUMMARY_PLACEHOLDER_INVALID'
   | 'REVIEW_SUMMARY_COUNT_MISMATCH'
+  | 'REVIEW_DECISION_DETAIL_INVALID'
   | 'REVIEW_ARTIFACT_CONFLICT'
   | 'REVIEW_PROVENANCE_INVALID'
   | 'REVIEW_TEMP_WRITE_FAILED'
@@ -106,8 +108,8 @@ function openReviewRound(content: string, action: string, round: number): boolea
   const section = locateActivityLog(content);
   if (!section) return false;
   const expected = `${action} (Round ${round})`;
-  return pairEntries(section.entries).filter((row) => (
-    row.step === expected && Boolean(row.started) && !row.done
+  return startedBackedRows(pairEntries(section.entries)).filter((row) => (
+    row.step === expected && !row.done
   )).length === 1;
 }
 
@@ -194,7 +196,11 @@ function finalizeReviewSummaryUnlocked(
 
   let rows;
   try {
-    rows = parseLedger(taskContent);
+    const ledger = parseLedgerDocument(taskContent);
+    if (!ledger.present) {
+      return failed(request, 'REVIEW_LEDGER_INVALID', `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`, resolved.taskId);
+    }
+    rows = ledger.rows;
   } catch (error) {
     return failed(request, 'REVIEW_LEDGER_INVALID', String(error), resolved.taskId);
   }
@@ -208,6 +214,16 @@ function finalizeReviewSummaryUnlocked(
     );
   }
   const stageStatus = summarizeLedgerStage(rows, stage);
+  const detailInspection = inspectDecisionDetailDuplicates(artifactContent);
+  if (!detailInspection.ok) {
+    return failed(
+      request,
+      'REVIEW_DECISION_DETAIL_INVALID',
+      `${detailInspection.code}: ${detailInspection.message}`,
+      resolved.taskId,
+      stageStatus
+    );
+  }
   const transformed = finalizeReviewSummaryContent(
     artifactContent,
     stageStatus.unresolvedFindingCounts

package/lib/task/review-fingerprint.ts

@@ -63,6 +63,16 @@ export function extractReviewBaseline(content: string): string {
   return match ? match[1]!.trim().replace(/`/g, "") : "";
 }
 
+export function extractReviewTargetHead(content: string): string {
+  const match = String(content).match(/^[-*]?\s*\*\*(?:审查目标提交|审查目标 HEAD|Review Target Commit|Review Target Head)\*\*[:：]\s*(.*?)\s*$/m);
+  return match ? match[1]!.trim().replace(/`/g, "") : "";
+}
+
+export function extractReviewedHead(content: string): string {
+  const match = String(content).match(/^[-*]?\s*\*\*(?:审查已检视提交|已检视提交|Reviewed Head Commit|Reviewed Head)\*\*[:：]\s*(.*?)\s*$/m);
+  return match ? match[1]!.trim().replace(/`/g, "") : "";
+}
+
 export function extractReviewDiffBase(content: string): string {
   const match = String(content).match(/^[-*]?\s*\*\*(?:审查差异基线|Reviewed Diff Base)\*\*[:：]\s*(.*?)\s*$/m);
   return match ? match[1]!.trim().replace(/`/g, "") : "";

package/lib/task/verification-engine.ts

@@ -7,6 +7,8 @@ import { fileURLToPath } from "node:url";
 
 import {
   extractReviewBaseline,
+  extractReviewTargetHead,
+  extractReviewedHead,
   extractReviewDiffBase,
   extractReviewDiffFingerprint,
   extractReviewedSnapshotTree,
@@ -22,12 +24,16 @@ import { resolveMaterializedReviewedHeadRelation } from "../platform/change-requ
 import { resolveReviewedHeadRelation } from "../platform/merged-pr-equivalence.ts";
 import { resolveLocalReviewedCommitRelation } from "../git/reviewed-commit-equivalence.ts";
 import { parseTypedTaskFrontmatter } from "./frontmatter.ts";
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from "./ledger.ts";
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from "./ledger.ts";
 import type { LedgerRow } from "./ledger.ts";
+import { isValidAgentInfraVersion } from "../version.ts";
 import { equalCounts, parseReviewSummary } from "./review-artifacts.ts";
+import { inspectDecisionDetailDuplicates } from "./decision-details.ts";
 import { loadVerificationConfig } from "./verification-config.ts";
 import { snapshotReview } from "../git/review-snapshot.ts";
 import { OrchestrationStateError, readRun } from "./orchestration.ts";
+import { resolveDeliveryTarget } from "./delivery-target.ts";
+import { readPrDeliveryFact } from "./pr-delivery-fact.ts";
 
 const TASK_ENUMS = {
   type: ["feature", "bugfix", "refactor", "docs", "chore"],
@@ -48,7 +54,6 @@ const DEFAULT_REQUIRED_FIELDS = [
 ];
 
 const DATE_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2})?$/;
-const AGENT_INFRA_VERSION_PATTERN = /^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 const ACTIVITY_LOG_PATTERN = /^- (\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2})?) — \*\*(.+?)\*\* by (.+?) — (.+)$/;
 // Start markers (action suffixed with ` [started]`) are excluded from the
 // "latest action" / freshness computation so a step's in-flight marker never
@@ -108,6 +113,8 @@ function runCheck(type: any, context: any, shared: any): any {
       return checkTaskMeta(context);
     case "artifact":
       return checkArtifact(context);
+    case "decision-details":
+      return checkDecisionDetails(context);
     case "implementation-input":
       return checkImplementationInput(context);
     case "activity-log":
@@ -192,15 +199,14 @@ function validateCleanCompletionEvidence(run: any): string | null {
     || !shaPattern.test(evidence.headTree)
     || !shaPattern.test(evidence.worktreeTree)
     || !shaPattern.test(evidence.lastReviewedCommit)
-    || !Number.isInteger(evidence.prNumber)
-    || evidence.prNumber <= 0
-    || !shaPattern.test(evidence.prHead)
+    || !(evidence.prNumber === null || (Number.isInteger(evidence.prNumber) && evidence.prNumber > 0))
+    || !(evidence.prHead === null || shaPattern.test(evidence.prHead))
   ) {
     return 'Clean completion evidence has an invalid structure';
   }
   if (
     evidence.head !== evidence.lastReviewedCommit
-    || evidence.head !== evidence.prHead
+    || (evidence.prHead !== null && evidence.head !== evidence.prHead)
     || evidence.headTree !== evidence.worktreeTree
   ) {
     return 'Clean completion evidence does not bind matching commit and tree identities';
@@ -273,12 +279,8 @@ function checkOrchestrationEvidence({ taskDir }: any): any {
   if (run.completionEvidence != null) {
     const evidenceError = validateCleanCompletionEvidence(run);
     if (evidenceError) return failResult('orchestration-evidence', evidenceError);
-  } else if (run.status === 'completed' && (
-      run.receipts.length === 0
-      || run.receipts.at(-1)?.stage !== 'commit'
-      || run.receipts.at(-1)?.status !== 'consumed'
-    )) {
-      return failResult('orchestration-evidence', 'Completed run requires a final consumed commit receipt');
+  } else if (run.status === 'completed') {
+    return failResult('orchestration-evidence', 'Completed run requires reviewed-head-clean completion evidence');
   }
   if (run.pendingDelegation && !['prepared', 'activated', 'stage-completed'].includes(run.pendingDelegation.status)) {
     return failResult('orchestration-evidence', `Pending receipt has unsafe status '${run.pendingDelegation.status}'`);
@@ -392,23 +394,20 @@ function checkTaskMeta({ taskDir, config }: any): any {
   const metadata = task.metadata;
   const requiredFields = config.required_fields || DEFAULT_REQUIRED_FIELDS;
   const missingFields = requiredFields.filter((field: any) => isBlank(metadata[field]));
-  const blockingMissingFields = missingFields.filter((field: any) => field !== "agent_infra_version");
+  const currentTask = metadata.status === 'active';
+  const blockingMissingFields = missingFields.filter((field: any) => field !== "agent_infra_version" || currentTask);
   const warnings = [];
-  if (missingFields.includes("agent_infra_version")) {
+  if (missingFields.includes("agent_infra_version") && !currentTask) {
     warnings.push("field 'agent_infra_version' missing — historical task or skipped version stamp");
   }
   if (blockingMissingFields.length > 0) {
     return failResult("task-meta", `Missing required fields: ${blockingMissingFields.join(", ")}`);
   }
 
-  if (
-    !isBlank(metadata.agent_infra_version) &&
-    metadata.agent_infra_version !== "unknown" &&
-    !AGENT_INFRA_VERSION_PATTERN.test(metadata.agent_infra_version)
-  ) {
+  if (currentTask && !isValidAgentInfraVersion(metadata.agent_infra_version)) {
     return failResult(
       "task-meta",
-      `Invalid agent_infra_version: ${metadata.agent_infra_version}`
+      `Invalid agent_infra_version: ${String(metadata.agent_infra_version ?? 'missing')}`
     );
   }
 
@@ -500,18 +499,18 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }: any): any {
     return failResult('required-pr-delivery', 'Project configuration is invalid');
   }
   const flow = projectConfig.prFlow;
-  const status = String(task.metadata.pr_status || 'pending');
-  const prNumber = parsePrNumber(task.metadata.pr_number);
+  const factRead = readPrDeliveryFact(task.metadata);
+  if (factRead.status === 'invalid') return failResult('required-pr-delivery', factRead.error.message);
+  const fact = factRead.status === 'valid' ? factRead.fact : null;
+  const status = fact?.state || 'unbound';
+  const prNumber = fact?.state === 'bound' ? fact.identity.number : null;
   if (flow === 'disabled') return passResult('required-pr-delivery', 'Pull request delivery is disabled by project policy');
-  if (flow === 'required' && (status !== 'created' || prNumber === null)) {
+  if (flow === 'required' && (status !== 'bound' || prNumber === null)) {
     return failResult('required-pr-delivery', 'Project policy requires a bound pull request before completion');
   }
-  if (flow !== 'required' && status === 'pending') {
+  if (flow !== 'required' && status === 'unbound') {
     return failResult('required-pr-delivery', 'Pull request delivery is pending; create a PR or explicitly skip it');
   }
-  if (status === 'created' && prNumber === null) {
-    return failResult('required-pr-delivery', 'Task claims a created pull request without a valid pr_number');
-  }
   if (flow === 'required') {
     if (mode === 'gate') {
       return passResult('required-pr-delivery', 'Bound pull request shape is valid; merged-state inspection is reserved for hard preflight');
@@ -527,6 +526,7 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }: any): any {
     const pullRequest = inspected.pullRequest;
     const repository = inspected.platform.repository?.toLowerCase() || '';
     const taskBranch = String(task.metadata.branch || '').trim();
+    const deliveryBaseRef = String(task.metadata.delivery_base_ref || projectConfig.delivery?.baseRef || '').trim();
     if (inspected.status !== 'no-op' || !pullRequest || pullRequest.number !== prNumber) {
       return failResult('required-pr-delivery', 'Bound pull request identity could not be verified');
     }
@@ -535,6 +535,7 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }: any): any {
       || pullRequest.repository.toLowerCase() !== repository
       || pullRequest.base.repository.toLowerCase() !== repository
       || (taskBranch && pullRequest.head.ref !== taskBranch)
+      || (deliveryBaseRef && pullRequest.base.ref !== deliveryBaseRef)
     ) {
       return failResult('required-pr-delivery', 'Bound pull request identity does not match the task');
     }
@@ -622,6 +623,18 @@ function checkArtifact({ taskDir, config, artifactFile }: any): any {
   );
 }
 
+function checkDecisionDetails({ taskDir, artifactFile }: any): any {
+  const resolvedArtifact = resolveArtifactPath(taskDir, "", artifactFile);
+  if (!resolvedArtifact.ok) return failResult("decision-details", resolvedArtifact.message);
+  const artifactPath = resolvedArtifact.path;
+  const stat = safeStat(artifactPath);
+  if (!stat?.isFile()) return failResult("decision-details", `Artifact not found: ${path.basename(artifactPath)}`);
+  if (stat.size === 0) return passResult("decision-details", `${path.basename(artifactPath)} contains no decision details`);
+  const inspection = inspectDecisionDetailDuplicates(fs.readFileSync(artifactPath, "utf8"));
+  if (!inspection.ok) return failResult("decision-details", `${path.basename(artifactPath)}: ${inspection.message}`);
+  return passResult("decision-details", `${path.basename(artifactPath)} has no duplicate decision detail ids`);
+}
+
 function checkReviewSummary({ taskDir, config, artifactFile }: any): any {
   const stage = String(config.stage || "");
   if (!["analysis", "plan", "code"].includes(stage)) {
@@ -640,7 +653,9 @@ function checkReviewSummary({ taskDir, config, artifactFile }: any): any {
   if (!task.ok) return failResult("review-summary", task.message);
   let rows;
   try {
-    rows = parseLedger(task.content);
+    const ledger = parseLedgerDocument(task.content);
+    if (!ledger.present) return failResult("review-summary", `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`);
+    rows = ledger.rows;
   } catch (error) {
     return failResult("review-summary", `Invalid disagreement ledger: ${String(error)}`);
   }
@@ -946,14 +961,11 @@ function checkReviewLedger({ taskDir, config }: any): any {
     return failResult("review-ledger", task.message);
   }
 
-  const section = getSectionContent(task.content, LEDGER_SECTION_NAMES);
-  if (!section.trim()) {
-    return passResult("review-ledger", "No disagreement ledger section; treated as no open disagreements");
-  }
-
   let rows;
   try {
-    rows = parseLedger(task.content).map((row) => [
+    const ledger = parseLedgerDocument(task.content);
+    if (!ledger.present) return failResult("review-ledger", `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`);
+    rows = ledger.rows.map((row) => [
       row.id, row.stage, row.round, row.severity, row.status, row.evidence
     ]);
   } catch (error) {
@@ -1099,9 +1111,12 @@ function checkPostReviewCommit({ taskDir, config }: any): any {
 
   const task = loadTask(taskDir);
   if (!task.ok) return failResult("post-review-commit", task.message);
+  const factRead = readPrDeliveryFact(task.metadata);
+  if (factRead.status === 'invalid') return failResult("post-review-commit", factRead.error.message);
+  const fact = factRead.status === 'valid' ? factRead.fact : null;
   const lastReviewedCommit = task.ok ? (task.metadata.last_reviewed_commit || "").trim() : "";
   const globs = resolvePostReviewGlobs(config, loadPostReviewConfig(repoRoot));
-  const hasPullRequest = Number(task.metadata.pr_number) > 0;
+  const hasPullRequest = fact?.state === 'bound';
   let inspected: ReturnType<typeof inspectPlatformPullRequest> | null = null;
   if (hasPullRequest) {
     inspected = inspectPlatformPullRequest(task.metadata.id, { cwd: gitRoot });
@@ -1248,7 +1263,11 @@ function resolvePostReviewExemption(content: string):
   | { ok: true; exemptions: readonly LedgerRow[] }
   | { ok: false; code: "POST_REVIEW_EXEMPTION_INVALID"; message: string } {
   try {
-    const rows = parseLedger(content);
+    const ledger = parseLedgerDocument(content);
+    if (!ledger.present) {
+      return { ok: false, code: "POST_REVIEW_EXEMPTION_INVALID", message: `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}` };
+    }
+    const rows = ledger.rows;
     const invalid = validateLedgerRows(rows);
     if (invalid) {
       return {
@@ -1287,7 +1306,8 @@ function checkReviewFact({ taskDir, artifactFile }: any): any {
 
   const content = fs.readFileSync(resolvedArtifact.path, "utf8");
   const verdict = parseReviewVerdict(content);
-  const reviewBaseline = extractReviewBaseline(content);
+  const reviewTargetHead = extractReviewTargetHead(content);
+  const reviewReviewedHead = extractReviewedHead(content);
   const reviewDiffBase = extractReviewDiffBase(content);
   const reviewedFingerprint = extractReviewDiffFingerprint(content);
   const reviewedTree = extractReviewedSnapshotTree(content);
@@ -1296,30 +1316,42 @@ function checkReviewFact({ taskDir, artifactFile }: any): any {
     return failResult("review-fact", `Unsupported review verdict '${verdict}'`);
   }
 
+  const deliveryRemote = String(task.metadata.delivery_remote || "").trim();
+  const deliveryBaseRef = String(task.metadata.delivery_base_ref || "").trim();
+  if (!deliveryRemote || !deliveryBaseRef) {
+    return failResult("review-fact", "Task delivery target is not bound; re-run task branch preparation before review-code");
+  }
+  if (!reviewTargetHead || !reviewReviewedHead || !reviewDiffBase) {
+    return failResult("review-fact", "Review fact must record target head, reviewed head, and diff base");
+  }
+
   let gitRoot;
   let head;
   let baseline;
+  let targetHead;
   let diffBase;
   try {
     gitRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
     head = execFileSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
-    baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewBaseline}^{commit}`], { encoding: "utf8" }).trim();
-    diffBase = execFileSync(
-      "git",
-      ["-C", gitRoot, "rev-parse", `${reviewDiffBase || reviewBaseline}^{commit}`],
-      { encoding: "utf8" }
-    ).trim();
+    const target = resolveDeliveryTarget(gitRoot, { remote: deliveryRemote, baseRef: deliveryBaseRef });
+    if (!target.ok) throw new Error(target.message);
+    const reviewedRef = reviewReviewedHead;
+    baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewedRef}^{commit}`], { encoding: "utf8" }).trim();
+    targetHead = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewTargetHead}^{commit}`], { encoding: "utf8" }).trim();
+    const computed = execFileSync("git", ["-C", gitRoot, "merge-base", baseline, targetHead], { encoding: "utf8" }).trim();
+    diffBase = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewDiffBase}^{commit}`], { encoding: "utf8" }).trim();
+    if (diffBase !== computed) throw new Error('saved review diff base does not match merge-base(reviewed head, target head)');
   } catch {
     return blockedResult(
       "review-fact",
-      `Unable to resolve review baseline '${reviewBaseline}' in the task repository; re-run review-code`
+      `Unable to resolve saved review commits in the task repository; re-run review-code`
     );
   }
 
   if (baseline !== head) {
     return failResult(
       "review-fact",
-      `Review baseline ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`
+      `Reviewed head ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`
     );
   }
 
@@ -1363,7 +1395,7 @@ function checkReviewFact({ taskDir, artifactFile }: any): any {
     if (cleanSnapshot && lastReviewedCommit !== baseline) {
       return failResult(
         "review-fact",
-        `Approved clean review must set task last_reviewed_commit to baseline ${baseline.slice(0, 8)}`
+        `Approved clean review must set task last_reviewed_commit to reviewed head ${baseline.slice(0, 8)}`
       );
     }
     if (!cleanSnapshot && lastReviewedCommit) {

package/lib/task/verification-review.ts

@@ -1,5 +1,7 @@
 export {
   extractReviewBaseline,
+  extractReviewTargetHead,
+  extractReviewedHead,
   extractReviewDiffBase,
   extractReviewDiffFingerprint,
   extractReviewedSnapshotTree,
@@ -8,4 +10,4 @@ export {
   parseReviewVerdict,
   resolvePostReviewGlobs
 } from './review-fingerprint.ts';
-export { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
+export { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';

package/lib/task/workspace-snapshot.ts

@@ -53,13 +53,6 @@ function captureWorktreeTree(repoRoot: string, forcedPath: string | null): strin
   }
 }
 
-function captureLegacyWorkspaceSnapshot(repoRoot: string, taskId: string | null): string {
-  const workspaceRelative = taskId
-    ? `.agents/workspace/active/${taskId}`
-    : '.agents/workspace/active';
-  return captureWorktreeTree(repoRoot, workspaceRelative);
-}
-
 function taskFileFingerprints(stateRoot: string, taskId: string | null): TaskFileFingerprint[] {
   const activeRoot = path.join(stateRoot, '.agents', 'workspace', 'active');
   const roots = taskId ? [path.join(activeRoot, taskId)] : [activeRoot];
@@ -73,6 +66,7 @@ function taskFileFingerprints(stateRoot: string, taskId: string | null): TaskFil
       return;
     }
     if (!stat.isFile() && !stat.isSymbolicLink()) return;
+    if (relative.startsWith('.agents/workspace/active/') && path.posix.basename(relative) === 'orchestration.json') return;
     const content = stat.isSymbolicLink()
       ? Buffer.from(fs.readlinkSync(absolute))
       : fs.readFileSync(absolute);
@@ -108,14 +102,11 @@ function decodeWorkspaceFingerprint(value: string): OrchestrationWorkspaceFinger
   }
 }
 
-function captureWorkspaceSnapshot(context: WorkspaceSnapshotContext): string;
-function captureWorkspaceSnapshot(repoRoot: string, taskId: string | null): string;
-function captureWorkspaceSnapshot(contextOrRoot: WorkspaceSnapshotContext | string, taskId?: string | null): string {
-  if (typeof contextOrRoot === 'string') return captureLegacyWorkspaceSnapshot(contextOrRoot, taskId ?? null);
+function captureWorkspaceSnapshot(context: WorkspaceSnapshotContext): string {
   return encodeWorkspaceFingerprint({
     version: 2,
-    gitTree: captureWorktreeTree(contextOrRoot.gitRoot, null),
-    taskFiles: taskFileFingerprints(contextOrRoot.stateRoot, contextOrRoot.taskId)
+    gitTree: captureWorktreeTree(context.gitRoot, null),
+    taskFiles: taskFileFingerprints(context.stateRoot, context.taskId)
   });
 }
 

package/lib/task/write.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { VERSION } from '../version.ts';
+import { isValidAgentInfraVersion, VERSION } from '../version.ts';
 import {
   parseTypedTaskFrontmatter,
   updateTaskFrontmatter
@@ -15,6 +15,7 @@ import type {
 import { allowsManualOverride } from './guard-override.ts';
 import type { ManualOverrideCapability } from './guard-override.ts';
 import { mutateTableRow, upsertSection } from './sections.ts';
+import { validateCurrentTaskContract } from './current-contract.ts';
 import type {
   TableRowDeleteMutation,
   TableRowUpsertMutation
@@ -84,6 +85,7 @@ type TaskWriteMetadata = {
 type TaskWriteErrorCode =
   | ResolveTaskRefErrorCode
   | 'TASK_STATE_MISMATCH'
+  | 'TASK_CURRENT_CONTRACT_INVALID'
   | 'TASK_READ_FAILED'
   | 'TASK_DOCUMENT_INVALID'
   | 'MUTATION_INVALID'
@@ -268,6 +270,13 @@ function writeTask(request: TaskWriteRequest, options: TaskWriteOptions = {}): T
     );
   }
 
+  if (resolved.state === 'active') {
+    const contract = validateCurrentTaskContract(original);
+    if (!contract.ok) {
+      return failure(request, identity, contract.code, contract.message);
+    }
+  }
+
   let candidate = original;
   const operations: TaskOperationSummary[] = [];
   try {
@@ -342,6 +351,16 @@ function writeTask(request: TaskWriteRequest, options: TaskWriteOptions = {}): T
       operations
     );
   }
+  if (resolved.state === 'active' && !isValidAgentInfraVersion(metadata.agentInfraVersion)) {
+    return failure(
+      request,
+      identity,
+      'TASK_CURRENT_CONTRACT_INVALID',
+      `metadata agentInfraVersion must be a valid v-prefixed semver (received ${metadata.agentInfraVersion})`,
+      operations,
+      metadata
+    );
+  }
 
   if (candidate === original) {
     return {