@fitlab-ai/agent-infra 0.9.10 → 0.9.12

package/dist/lib/task/pr-delivery-fact.js

@@ -0,0 +1,182 @@
+const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
+function factError(message) {
+    return Object.assign(new Error(`PR_DELIVERY_FACT_INVALID: ${message}`), { code: 'PR_DELIVERY_FACT_INVALID' });
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function exactKeys(value, keys, label) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+        throw factError(`${label} has an invalid field set`);
+    }
+}
+function text(value, label) {
+    if (typeof value !== 'string' || !value || value.trim() !== value)
+        throw factError(`${label} must be a non-empty string`);
+    return value;
+}
+function nullableText(value, label) {
+    return value === null ? null : text(value, label);
+}
+function positiveNumber(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw factError(`${label} must be a positive integer`);
+    return value;
+}
+function optionalTimestamp(value, label) {
+    const result = nullableText(value, label);
+    if (result !== null && Number.isNaN(Date.parse(result)))
+        throw factError(`${label} must be a valid timestamp`);
+    return result;
+}
+function parseIdentity(value) {
+    if (!isRecord(value))
+        throw factError('identity must be an object');
+    exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'identity');
+    const head = parseRef(value.head, 'head');
+    const base = parseRef(value.base, 'base');
+    return {
+        repository: text(value.repository, 'identity.repository'),
+        number: positiveNumber(value.number, 'identity.number'),
+        nodeId: text(value.nodeId, 'identity.nodeId'),
+        url: text(value.url, 'identity.url'),
+        head,
+        base
+    };
+}
+function parseRef(value, label) {
+    if (!isRecord(value))
+        throw factError(`${label} must be an object`);
+    exactKeys(value, ['repository', 'ref', 'sha'], label);
+    return {
+        repository: text(value.repository, `${label}.repository`),
+        ref: text(value.ref, `${label}.ref`),
+        sha: text(value.sha, `${label}.sha`)
+    };
+}
+function parseFact(value) {
+    if (!isRecord(value))
+        throw factError('fact must be an object');
+    if (value.version !== 1 || typeof value.state !== 'string')
+        throw factError('version or state is invalid');
+    if (value.state === 'unbound') {
+        exactKeys(value, ['version', 'state', 'reason'], 'unbound fact');
+        if (value.reason !== 'initial')
+            throw factError('unbound reason is invalid');
+        return { version: 1, state: 'unbound', reason: value.reason };
+    }
+    if (value.state === 'skipped') {
+        exactKeys(value, ['version', 'state', 'reason', 'decidedAt'], 'skipped fact');
+        if (value.reason !== 'explicit')
+            throw factError('skipped reason is invalid');
+        const decidedAt = text(value.decidedAt, 'skipped.decidedAt');
+        if (Number.isNaN(Date.parse(decidedAt)))
+            throw factError('skipped.decidedAt must be a valid timestamp');
+        return { version: 1, state: 'skipped', reason: 'explicit', decidedAt };
+    }
+    if (value.state !== 'bound')
+        throw factError('state is invalid');
+    exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'bound fact');
+    if (!isRecord(value.binding))
+        throw factError('binding must be an object');
+    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
+    if (value.binding.status !== 'verified')
+        throw factError('binding status is invalid');
+    const sources = ['created', 'reused', 'explicit-bind', 'external-unique', 'external-explicit'];
+    if (!sources.includes(value.binding.source))
+        throw factError('binding source is invalid');
+    const verifiedAt = text(value.binding.verifiedAt, 'binding.verifiedAt');
+    if (Number.isNaN(Date.parse(verifiedAt)))
+        throw factError('binding.verifiedAt must be a valid timestamp');
+    const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'binding.issueNumber');
+    if (value.binding.remoteState !== 'open' && value.binding.remoteState !== 'closed')
+        throw factError('binding.remoteState is invalid');
+    const mergedAt = optionalTimestamp(value.binding.mergedAt, 'binding.mergedAt');
+    const mergeCommitSha = nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha');
+    if (Boolean(mergedAt) !== Boolean(mergeCommitSha))
+        throw factError('mergedAt and mergeCommitSha must be paired');
+    if (!isRecord(value.provenance))
+        throw factError('provenance must be an object');
+    exactKeys(value.provenance, ['establishedBy'], 'provenance');
+    const provenance = ['create-post', 'reuse', 'explicit-bind', 'external-unique', 'external-explicit'];
+    if (!provenance.includes(value.provenance.establishedBy))
+        throw factError('provenance.establishedBy is invalid');
+    if (value.provenance.establishedBy !== provenanceForSource(value.binding.source)) {
+        throw factError('binding.source and provenance.establishedBy do not match');
+    }
+    return {
+        version: 1,
+        state: 'bound',
+        identity: parseIdentity(value.identity),
+        binding: {
+            status: 'verified',
+            source: value.binding.source,
+            verifiedAt,
+            issueNumber,
+            remoteState: value.binding.remoteState,
+            mergedAt,
+            mergeCommitSha
+        },
+        provenance: { establishedBy: value.provenance.establishedBy }
+    };
+}
+function decodePrDeliveryFact(value) {
+    if (typeof value === 'string') {
+        try {
+            return parseFact(JSON.parse(value));
+        }
+        catch (error) {
+            throw error instanceof Error && error.message.startsWith('PR_DELIVERY_FACT_INVALID:') ? error : factError('value is not valid JSON');
+        }
+    }
+    return parseFact(value);
+}
+function encodePrDeliveryFact(fact) {
+    return JSON.stringify(parseFact(fact));
+}
+function readPrDeliveryFact(metadata) {
+    if (!Object.hasOwn(metadata, PR_DELIVERY_FACT_KEY) || metadata[PR_DELIVERY_FACT_KEY] === '')
+        return { status: 'missing', fact: null };
+    try {
+        return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY]) };
+    }
+    catch (error) {
+        return { status: 'invalid', fact: null, error: error instanceof Error ? error : factError(String(error)) };
+    }
+}
+function buildUnboundFact() {
+    return { version: 1, state: 'unbound', reason: 'initial' };
+}
+function buildSkippedFact(decidedAt) {
+    return parseFact({ version: 1, state: 'skipped', reason: 'explicit', decidedAt });
+}
+function provenanceForSource(source) {
+    return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source;
+}
+function buildBoundFact(input) {
+    return parseFact({
+        version: 1,
+        state: 'bound',
+        identity: input.identity,
+        binding: {
+            status: 'verified',
+            source: input.source,
+            verifiedAt: input.verifiedAt,
+            issueNumber: input.issueNumber ?? null,
+            remoteState: input.remoteState,
+            mergedAt: input.mergedAt ?? null,
+            mergeCommitSha: input.mergeCommitSha ?? null
+        },
+        provenance: { establishedBy: provenanceForSource(input.source) }
+    });
+}
+function factFrontmatterMutation(fact) {
+    return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } };
+}
+function identityFromPullRequest(pullRequest) {
+    return parseIdentity(pullRequest);
+}
+export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact };
+//# sourceMappingURL=pr-delivery-fact.js.map

package/dist/lib/task/review-artifacts.js

@@ -159,27 +159,46 @@ function finalizeReviewSummaryContent(content, counts) {
         content: content.slice(0, parsed.findingsStart) + line + content.slice(parsed.findingsEnd)
     };
 }
+function resolveCanonicalVerdict(summary) {
+    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) {
     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;
+    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 { artifactName, equalCounts, escapeRegExp, extractSection, finalizeReviewSummaryContent, maxRound, normalizeVerdict, parseReviewSummary, parseVerdict };
+export { artifactName, equalCounts, escapeRegExp, extractSection, finalizeReviewSummaryContent, maxRound, normalizeVerdict, parseReviewSummary, parseVerdict, resolveCanonicalVerdict };
 //# sourceMappingURL=review-artifacts.js.map

package/dist/lib/task/review-finalization.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { locateActivityLog, pairEntries } from './activity-log.js';
+import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { parseArtifactName, validateCompletedArtifact } from './artifact-lifecycle.js';
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { finalizeReviewSummaryContent } from './review-artifacts.js';
+import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
@@ -40,7 +41,7 @@ function openReviewRound(content, action, round) {
     if (!section)
         return false;
     const expected = `${action} (Round ${round})`;
-    return pairEntries(section.entries).filter((row) => (row.step === expected && Boolean(row.started) && !row.done)).length === 1;
+    return startedBackedRows(pairEntries(section.entries)).filter((row) => (row.step === expected && !row.done)).length === 1;
 }
 function cleanupTemp(fileSystem, tempPath) {
     try {
@@ -103,7 +104,11 @@ function finalizeReviewSummaryUnlocked(request, options = {}) {
     }
     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);
@@ -113,6 +118,10 @@ function finalizeReviewSummaryUnlocked(request, options = {}) {
         return failed(request, 'REVIEW_LEDGER_INVALID', `${ledgerError.code}: ${ledgerError.message}`, resolved.taskId);
     }
     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);
     if (!transformed.ok) {
         return failed(request, transformed.code, transformed.message, resolved.taskId, stageStatus);

package/dist/lib/task/review-fingerprint.js

@@ -44,6 +44,14 @@ export function extractReviewBaseline(content) {
     const match = String(content).match(/^[-*]?\s*\*\*(?:审查基线提交|Review Baseline Commit)\*\*[:：]\s*(.*?)\s*$/m);
     return match ? match[1].trim().replace(/`/g, "") : "";
 }
+export function extractReviewTargetHead(content) {
+    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) {
+    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) {
     const match = String(content).match(/^[-*]?\s*\*\*(?:审查差异基线|Reviewed Diff Base)\*\*[:：]\s*(.*?)\s*$/m);
     return match ? match[1].trim().replace(/`/g, "") : "";

package/dist/lib/task/verification-engine.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import process from "node:process";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { extractReviewBaseline, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
+import { extractReviewBaseline, extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
 import { check as checkPlatformSync } from "../platform/verification-sync.js";
 import { check as checkRequiredChecks } from "../platform/verification-required.js";
 import { inspectPlatformPullRequest } from "../platform/pull-requests.js";
@@ -12,11 +12,15 @@ import { resolveMaterializedReviewedHeadRelation } from "../platform/change-requ
 import { resolveReviewedHeadRelation } from "../platform/merged-pr-equivalence.js";
 import { resolveLocalReviewedCommitRelation } from "../git/reviewed-commit-equivalence.js";
 import { parseTypedTaskFrontmatter } from "./frontmatter.js";
-import { parseLedger, summarizeLedgerStage, validateLedgerRows } from "./ledger.js";
+import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from "./ledger.js";
+import { isValidAgentInfraVersion } from "../version.js";
 import { equalCounts, parseReviewSummary } from "./review-artifacts.js";
+import { inspectDecisionDetailDuplicates } from "./decision-details.js";
 import { loadVerificationConfig } from "./verification-config.js";
 import { snapshotReview } from "../git/review-snapshot.js";
 import { OrchestrationStateError, readRun } from "./orchestration.js";
+import { resolveDeliveryTarget } from "./delivery-target.js";
+import { readPrDeliveryFact } from "./pr-delivery-fact.js";
 const TASK_ENUMS = {
     type: ["feature", "bugfix", "refactor", "docs", "chore"],
     workflow: ["feature-development", "bug-fix", "refactoring"],
@@ -34,7 +38,6 @@ const DEFAULT_REQUIRED_FIELDS = [
     "assigned_to"
 ];
 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
@@ -89,6 +92,8 @@ function runCheck(type, context, shared) {
             return checkTaskMeta(context);
         case "artifact":
             return checkArtifact(context);
+        case "decision-details":
+            return checkDecisionDetails(context);
         case "implementation-input":
             return checkImplementationInput(context);
         case "activity-log":
@@ -173,13 +178,12 @@ function validateCleanCompletionEvidence(run) {
         || !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';
     }
@@ -248,10 +252,8 @@ function checkOrchestrationEvidence({ taskDir }) {
         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}'`);
@@ -352,18 +354,17 @@ function checkTaskMeta({ taskDir, config }) {
     const metadata = task.metadata;
     const requiredFields = config.required_fields || DEFAULT_REQUIRED_FIELDS;
     const missingFields = requiredFields.filter((field) => isBlank(metadata[field]));
-    const blockingMissingFields = missingFields.filter((field) => field !== "agent_infra_version");
+    const currentTask = metadata.status === 'active';
+    const blockingMissingFields = missingFields.filter((field) => 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)) {
-        return failResult("task-meta", `Invalid agent_infra_version: ${metadata.agent_infra_version}`);
+    if (currentTask && !isValidAgentInfraVersion(metadata.agent_infra_version)) {
+        return failResult("task-meta", `Invalid agent_infra_version: ${String(metadata.agent_infra_version ?? 'missing')}`);
     }
     const invalidDates = ["created_at", "updated_at", "completed_at", "blocked_at", "cancelled_at"]
         .filter((field) => !isBlank(metadata[field]) && !DATE_TIME_PATTERN.test(metadata[field]));
@@ -432,19 +433,20 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }) {
         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');
@@ -456,13 +458,15 @@ function checkRequiredPrDelivery({ taskDir, repositoryRoot, mode }) {
         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');
         }
         if (!repository
             || pullRequest.repository.toLowerCase() !== repository
             || pullRequest.base.repository.toLowerCase() !== repository
-            || (taskBranch && pullRequest.head.ref !== taskBranch)) {
+            || (taskBranch && pullRequest.head.ref !== taskBranch)
+            || (deliveryBaseRef && pullRequest.base.ref !== deliveryBaseRef)) {
             return failResult('required-pr-delivery', 'Bound pull request identity does not match the task');
         }
         if (pullRequest.state !== 'closed' || !pullRequest.mergedAt || !pullRequest.mergeCommitSha) {
@@ -527,6 +531,21 @@ function checkArtifact({ taskDir, config, artifactFile }) {
     }
     return passResult("artifact", `${path.basename(artifactPath)} passed (${requiredSections.length} sections)`);
 }
+function checkDecisionDetails({ taskDir, artifactFile }) {
+    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 }) {
     const stage = String(config.stage || "");
     if (!["analysis", "plan", "code"].includes(stage)) {
@@ -547,7 +566,10 @@ function checkReviewSummary({ taskDir, config, artifactFile }) {
         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)}`);
@@ -817,13 +839,12 @@ function checkReviewLedger({ taskDir, config }) {
     if (!task.ok) {
         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
         ]);
     }
@@ -947,9 +968,13 @@ function checkPostReviewCommit({ taskDir, config }) {
     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 = null;
     if (hasPullRequest) {
         inspected = inspectPlatformPullRequest(task.metadata.id, { cwd: gitRoot });
@@ -1068,7 +1093,11 @@ function formatPostReviewExemptions(exemptions) {
 }
 function resolvePostReviewExemption(content) {
     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 {
@@ -1101,28 +1130,46 @@ function checkReviewFact({ taskDir, artifactFile }) {
     }
     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);
     if (!["通过", "需要修改", "拒绝", "Approved", "Changes Requested", "Rejected"].includes(verdict)) {
         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`);
+        return blockedResult("review-fact", `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`);
+        return failResult("review-fact", `Reviewed head ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`);
     }
     let actualSnapshot;
     try {
@@ -1147,7 +1194,7 @@ function checkReviewFact({ taskDir, artifactFile }) {
         const lastReviewedCommit = String(task.metadata.last_reviewed_commit || "").trim();
         const cleanSnapshot = actualSnapshot.tree === execFileSync("git", ["-C", gitRoot, "rev-parse", `${baseline}^{tree}`], { encoding: "utf8" }).trim();
         if (cleanSnapshot && lastReviewedCommit !== baseline) {
-            return failResult("review-fact", `Approved clean review must set task last_reviewed_commit to baseline ${baseline.slice(0, 8)}`);
+            return failResult("review-fact", `Approved clean review must set task last_reviewed_commit to reviewed head ${baseline.slice(0, 8)}`);
         }
         if (!cleanSnapshot && lastReviewedCommit) {
             return failResult("review-fact", "Approved review with uncommitted changes must remain unanchored until commit");

package/dist/lib/task/verification-review.js

@@ -1,3 +1,3 @@
-export { extractReviewBaseline, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from './review-fingerprint.js';
-export { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
+export { extractReviewBaseline, extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from './review-fingerprint.js';
+export { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 //# sourceMappingURL=verification-review.js.map

package/dist/lib/task/workspace-snapshot.js

@@ -26,12 +26,6 @@ function captureWorktreeTree(repoRoot, forcedPath) {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
-function captureLegacyWorkspaceSnapshot(repoRoot, taskId) {
-    const workspaceRelative = taskId
-        ? `.agents/workspace/active/${taskId}`
-        : '.agents/workspace/active';
-    return captureWorktreeTree(repoRoot, workspaceRelative);
-}
 function taskFileFingerprints(stateRoot, taskId) {
     const activeRoot = path.join(stateRoot, '.agents', 'workspace', 'active');
     const roots = taskId ? [path.join(activeRoot, taskId)] : [activeRoot];
@@ -46,6 +40,8 @@ function taskFileFingerprints(stateRoot, taskId) {
         }
         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);
@@ -81,13 +77,11 @@ function decodeWorkspaceFingerprint(value) {
         throw new Error(`ORCHESTRATION_SNAPSHOT_FAILED: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-function captureWorkspaceSnapshot(contextOrRoot, taskId) {
-    if (typeof contextOrRoot === 'string')
-        return captureLegacyWorkspaceSnapshot(contextOrRoot, taskId ?? null);
+function captureWorkspaceSnapshot(context) {
     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)
     });
 }
 function captureRepositorySnapshot(repoRoot) {