@fitlab-ai/agent-infra 0.9.10 → 0.9.11

package/lib/task/lifecycle.ts

@@ -12,6 +12,8 @@ import {
 } from './short-id.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskFileSystem, TaskMutation, TaskOperationSummary, TaskWriteMetadata } from './write.ts';
+import { validateCurrentTaskContract } from './current-contract.ts';
+import { isValidAgentInfraVersion } from '../version.ts';
 
 const lifecycleIntentCatalog = [
   'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
@@ -126,6 +128,14 @@ function failed(request: Pick<TaskLifecycleRequest, 'taskRef' | 'intent'>, error
   };
 }
 
+export function taskLifecycleFailure(
+  request: Pick<TaskLifecycleRequest, 'taskRef' | 'intent'>,
+  error: LifecycleError,
+  taskId: string | null = null
+): TaskLifecycleResult {
+  return failed(request, error, { taskId });
+}
+
 function normalizedRequest(request: TaskLifecycleRequest): TaskLifecycleRequest | LifecycleError {
   if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent as TaskLifecycleIntent)) {
     return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -385,6 +395,10 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   catch (error) { return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: error instanceof Error ? error.message : String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath }); }
   if (frontmatter.id !== taskId) return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   if (!locateActivityLog(content) && !allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING')) return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+  if (spec.target === 'active') {
+    const contract = validateCurrentTaskContract(content);
+    if (!contract.ok) return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: contract.message }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+  }
   const registryRequest = executeShortIdCommand({
     operation: 'list', activeDir: path.join(repoRoot, '.agents', 'workspace', 'active'),
     shortIdLength: configuredShortIdLength(repoRoot)
@@ -408,6 +422,9 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     try { journal = parseJournal(io.readFileSync(initialJournalPath)); }
     catch (error) { return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath }); }
     if (journal.taskId !== taskId || journal.intent !== request.intent) return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+    if (spec.target === 'active' && !isValidAgentInfraVersion(journal.metadata.agentInfraVersion)) {
+      return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: `journal metadata agentInfraVersion must be a valid v-prefixed semver (received ${journal.metadata.agentInfraVersion})` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+    }
     if (request.dryRun) {
       if (!journal.failure) return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
       return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: STEPS.filter((step) => !journal.completedSteps.includes(step)) });
@@ -418,6 +435,9 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     let metadata: TaskWriteMetadata;
     try { metadata = (options.metadataProvider ?? captureTaskWriteMetadata)(); }
     catch (error) { return failed(request, { code: 'LIFECYCLE_METADATA_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath }); }
+    if (spec.target === 'active' && !isValidAgentInfraVersion(metadata.agentInfraVersion)) {
+      return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: `metadata agentInfraVersion must be a valid v-prefixed semver (received ${metadata.agentInfraVersion})` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+    }
     journal = { version: 1, taskId, intent: request.intent, intentDigest: digest, sourceState, targetState: spec.target, metadata, completedSteps: [] };
     if (request.dryRun) {
       const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));

package/lib/task/orchestration.ts

@@ -3,9 +3,11 @@ import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
-import { parseReviewSummary } from './review-artifacts.ts';
+import { validateCurrentTaskContract } from './current-contract.ts';
+import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.ts';
 import { inspectArtifactDirectory } 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 { LedgerDocument } from './ledger.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import {
   activateDelegation,
@@ -530,14 +532,20 @@ function hasReviewAfterArtifact(taskDir: string, family: string, reviewFamily: s
     && review.reviewedInput?.name === artifact.latest.name;
 }
 
-function latestReviewApproved(taskDir: string, family: 'review-analysis' | 'review-plan' | 'review-code'): boolean {
+function latestReviewApproved(taskDir: string, family: 'review-analysis' | 'review-plan' | 'review-code'): { approved: boolean; error: string | null } {
   const round = highestRound(taskDir, family);
-  if (round === 0) return false;
-  const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, artifactName(family, round)), 'utf8'));
-  return parsed.ok && parsed.summary.verdict === 'Approved' && parsed.summary.counts !== null;
+  if (round === 0) return { approved: false, error: null };
+  let content: string;
+  try { content = fs.readFileSync(path.join(taskDir, artifactName(family, round)), 'utf8'); }
+  catch (error) { return { approved: false, error: String(error) }; }
+  const parsed = parseReviewSummary(content);
+  if (!parsed.ok) return { approved: false, error: `${parsed.code}: ${parsed.message}` };
+  const verdict = resolveCanonicalVerdict(parsed.summary);
+  if (!verdict.ok) return { approved: false, error: `${verdict.code}: ${verdict.message}` };
+  return { approved: verdict.verdict === 'Approved', error: null };
 }
 
-function routeFromFacts(taskDir: string): Omit<OrchestrationNext, 'requestedModel' | 'requestedReasoningEffort'> | null {
+function routeFromFacts(taskDir: string): Omit<OrchestrationNext, 'requestedModel' | 'requestedReasoningEffort'> | { error: string } | null {
   const analysisRound = highestRound(taskDir, 'analysis');
   const analysisReviewRound = highestRound(taskDir, 'review-analysis');
   const planRound = highestRound(taskDir, 'plan');
@@ -552,7 +560,9 @@ function routeFromFacts(taskDir: string): Omit<OrchestrationNext, 'requestedMode
     const round = analysisReviewRound + 1;
     return { action: 'review-analysis', role: 'reviewer', stage: 'review-analysis', round, artifact: artifactName('review-analysis', round) };
   }
-  if (!latestReviewApproved(taskDir, 'review-analysis')) {
+  const analysisVerdict = latestReviewApproved(taskDir, 'review-analysis');
+  if (analysisVerdict.error) return { error: analysisVerdict.error };
+  if (!analysisVerdict.approved) {
     const round = analysisRound + 1;
     return { action: 'analyze-task', role: 'executor', stage: 'analysis', round, artifact: artifactName('analysis', round) };
   }
@@ -564,7 +574,9 @@ function routeFromFacts(taskDir: string): Omit<OrchestrationNext, 'requestedMode
     const round = planReviewRound + 1;
     return { action: 'review-plan', role: 'reviewer', stage: 'review-plan', round, artifact: artifactName('review-plan', round) };
   }
-  if (!latestReviewApproved(taskDir, 'review-plan')) {
+  const planVerdict = latestReviewApproved(taskDir, 'review-plan');
+  if (planVerdict.error) return { error: planVerdict.error };
+  if (!planVerdict.approved) {
     const round = planRound + 1;
     return { action: 'plan-task', role: 'executor', stage: 'plan', round, artifact: artifactName('plan', round) };
   }
@@ -576,7 +588,9 @@ function routeFromFacts(taskDir: string): Omit<OrchestrationNext, 'requestedMode
     const round = codeReviewRound + 1;
     return { action: 'review-code', role: 'reviewer', stage: 'review-code', round, artifact: artifactName('review-code', round) };
   }
-  if (!latestReviewApproved(taskDir, 'review-code')) {
+  const codeVerdict = latestReviewApproved(taskDir, 'review-code');
+  if (codeVerdict.error) return { error: codeVerdict.error };
+  if (!codeVerdict.approved) {
     const round = codeRound + 1;
     return { action: 'code-task', role: 'executor', stage: 'code', round, artifact: artifactName('code', round) };
   }
@@ -599,12 +613,21 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
     return failed('ORCHESTRATION_TASK_READ_FAILED', String(error), resolved.taskId);
   }
   let metadata: ReturnType<typeof parseTypedTaskFrontmatter>;
-  try {
-    metadata = parseTypedTaskFrontmatter(content);
-  } catch (error) {
-    return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+  let currentLedger: LedgerDocument | null = null;
+  if (resolved.state === 'active') {
+    const contract = validateCurrentTaskContract(content);
+    if (!contract.ok) return failed('ORCHESTRATION_CURRENT_CONTRACT_INVALID', contract.message, resolved.taskId);
+    metadata = contract.metadata;
+    currentLedger = contract.ledger;
+  } else {
+    try {
+      metadata = parseTypedTaskFrontmatter(content);
+    } catch (error) {
+      return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
   }
   const routed = routeFromFacts(resolved.taskDir);
+  if (routed && 'error' in routed) return failed('ORCHESTRATION_REVIEW_INVALID', routed.error, resolved.taskId);
   if (!routed) return failed('ORCHESTRATION_ROUTE_UNKNOWN', 'cannot determine a unique lifecycle action', resolved.taskId);
   const run = readRun(resolved.taskDir);
   const policy = run ? rolePolicy(run, routed.role) : null;
@@ -622,7 +645,9 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
     if (!review.ok || review.summary.manualValidation === null) {
       return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
     }
-    const rows = parseLedger(content);
+    const ledger = currentLedger ?? parseLedgerDocument(content);
+    if (!ledger.present) return failed('ORCHESTRATION_CURRENT_CONTRACT_INVALID', `${LEDGER_SECTION_MISSING_CODE}: ${LEDGER_SECTION_MISSING_MESSAGE}`, resolved.taskId);
+    const rows = ledger.rows;
     const ledgerError = validateLedgerRows(rows);
     if (ledgerError) return failed('ORCHESTRATION_LEDGER_INVALID', ledgerError.message, resolved.taskId);
     if (!summarizeLedgerStage(rows, 'code').canAdvance) {

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, repairDecisionDetailDuplicates } 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,14 +214,34 @@ function finalizeReviewSummaryUnlocked(
     );
   }
   const stageStatus = summarizeLedgerStage(rows, stage);
+  const repaired = repairDecisionDetailDuplicates(artifactContent);
+  if (!repaired.ok) {
+    return failed(
+      request,
+      'REVIEW_DECISION_DETAIL_INVALID',
+      `${repaired.code}: ${repaired.message}`,
+      resolved.taskId,
+      stageStatus
+    );
+  }
+  const detailInspection = inspectDecisionDetailDuplicates(repaired.content);
+  if (!detailInspection.ok) {
+    return failed(
+      request,
+      'REVIEW_DECISION_DETAIL_INVALID',
+      `${detailInspection.code}: ${detailInspection.message}`,
+      resolved.taskId,
+      stageStatus
+    );
+  }
   const transformed = finalizeReviewSummaryContent(
-    artifactContent,
+    repaired.content,
     stageStatus.unresolvedFindingCounts
   );
   if (!transformed.ok) {
     return failed(request, transformed.code, transformed.message, resolved.taskId, stageStatus);
   }
-  if (!transformed.changed) {
+  if (!repaired.changed && !transformed.changed) {
     return {
       ...failed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, stageStatus),
       status: 'no-op',

package/lib/task/verification-engine.ts

@@ -22,9 +22,11 @@ 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";
@@ -48,7 +50,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 +109,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":
@@ -392,23 +395,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')}`
     );
   }
 
@@ -622,6 +622,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 +652,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 +960,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) {
@@ -1248,7 +1259,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 {

package/lib/task/verification-review.ts

@@ -8,4 +8,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 {