@fitlab-ai/agent-infra 0.9.10 → 0.9.12

package/dist/lib/task/ledger-intents.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { declareImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
-import { LEDGER_COLUMNS, LEDGER_HEADINGS, nextHdId, parseLedger, validateLedgerRows } from './ledger.js';
+import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, nextHdId, parseLedgerDocument, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
 import { allowsManualOverride } from './guard-override.js';
@@ -26,6 +26,8 @@ function normalizedEvidence(value) {
 }
 function ledgerReadErrorCode(error) {
     const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    if (code === LEDGER_SECTION_MISSING_CODE)
+        return code;
     return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
 }
 function maxHandshakeRounds(repoRoot) {
@@ -60,13 +62,7 @@ function rowMutation(row) {
     };
 }
 function ledgerSectionMutation(content) {
-    if (/^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/m.test(content))
-        return [];
-    const english = /^##\s+Activity Log\s*$/m.test(content);
-    return [{
-            kind: 'section', aliases: LEDGER_HEADINGS, heading: english ? 'Review Disagreement Ledger' : '审查分歧账本',
-            body: `| ${LEDGER_COLUMNS.join(' | ')} |\n|----|-------|-------|----------|--------|----------|`
-        }];
+    return [];
 }
 function implementationInputMutation(content, rows) {
     const english = /^##\s+Activity Log\s*$/m.test(content);
@@ -92,7 +88,10 @@ function applyLedgerIntent(intent, options = {}) {
     let rows;
     try {
         content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-        rows = parseLedger(content);
+        const ledger = parseLedgerDocument(content);
+        if (!ledger.present)
+            return failed(intent, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, resolved.taskId);
+        rows = ledger.rows;
     }
     catch (error) {
         return failed(intent, ledgerReadErrorCode(error), error instanceof Error ? error.message : String(error), resolved.taskId);

package/dist/lib/task/ledger.js

@@ -12,18 +12,25 @@ const LEDGER_TERMINAL = new Set(['confirmed', 'closed', 'human-decided']);
 // Statuses that represent a decision row awaiting or carrying a human ruling.
 const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
 const FINDING_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'confirmed', 'needs-human-decision', 'closed', 'human-decided']);
+const LEDGER_SECTION_MISSING_CODE = 'LEDGER_SECTION_MISSING';
+const LEDGER_SECTION_MISSING_MESSAGE = 'review disagreement ledger section is missing';
 function isReviewStage(stage) {
     return stage === 'analysis' || stage === 'plan' || stage === 'code';
 }
 // Parse all rows of the disagreement ledger table. Skips the heading, the
 // header row (`| id | ... |`) and the `|---|` separator; ignores non-`|` lines.
 // Rows with fewer than 6 columns are skipped (mirrors the JS gate parser).
-function parseLedger(content) {
+function parseLedgerDocument(content) {
     const table = parseTable(content, { sectionAliases: LEDGER_HEADINGS, columns: LEDGER_COLUMNS });
-    return table?.rows.map(({ values, sourceLine }) => ({
-        id: values.id, stage: values.stage, round: values.round, severity: values.severity,
-        status: values.status, evidence: values.evidence, sourceLine
-    })) ?? [];
+    if (!table)
+        return { present: false, rows: [] };
+    return {
+        present: true,
+        rows: table.rows.map(({ values, sourceLine }) => ({
+            id: values.id, stage: values.stage, round: values.round, severity: values.severity,
+            status: values.status, evidence: values.evidence, sourceLine
+        }))
+    };
 }
 function validateLedgerRows(rows) {
     const seen = new Set();
@@ -104,5 +111,5 @@ function nextHdId(rows) {
     }
     return `HD-${max + 1}`;
 }
-export { LEDGER_HEADINGS, LEDGER_COLUMNS, parseLedger, nextHdId, isReviewStage, validateLedgerRows, summarizeLedgerStage, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES };
+export { LEDGER_HEADINGS, LEDGER_COLUMNS, parseLedgerDocument, nextHdId, isReviewStage, validateLedgerRows, summarizeLedgerStage, LEDGER_TERMINAL, HUMAN_DECISION_STATUSES, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE };
 //# sourceMappingURL=ledger.js.map

package/dist/lib/task/lifecycle.js

@@ -7,11 +7,14 @@ import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { locateHotTaskDirs, resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { configuredShortIdLength, executeShortIdCommand, loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { validateCurrentTaskContract } from './current-contract.js';
+import { isValidAgentInfraVersion } from '../version.js';
 const lifecycleIntentCatalog = [
     'block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore'
 ];
 const lifecycleFailureCatalog = [
     'LIFECYCLE_DIRECTORY_RENAME_FAILED',
+    'LIFECYCLE_DIRECTORY_COPY_FAILED',
     'LIFECYCLE_DOCUMENT_INVALID',
     'LIFECYCLE_FINAL_STATE_INVALID',
     'LIFECYCLE_IDENTITY_CONFLICT',
@@ -57,6 +60,9 @@ function failed(request, error, extra = {}) {
         error, ...extra
     };
 }
+export function taskLifecycleFailure(request, error, taskId = null) {
+    return failed(request, error, { taskId });
+}
 function normalizedRequest(request) {
     if (!request || typeof request !== 'object' || !lifecycleIntentCatalog.includes(request.intent)) {
         return { code: 'LIFECYCLE_PAYLOAD_INVALID', message: 'intent is not in the lifecycle catalog' };
@@ -290,6 +296,65 @@ function parseJournal(content) {
     }
     return value;
 }
+function directoryManifest(root) {
+    const entries = [];
+    const visit = (current, relative = '') => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
+            const relativePath = relative ? path.join(relative, entry.name) : entry.name;
+            const absolute = path.join(current, entry.name);
+            const stat = fs.lstatSync(absolute);
+            if (stat.isSymbolicLink())
+                throw new Error(`symbolic link is not allowed in lifecycle directory: ${relativePath}`);
+            if (entry.isDirectory()) {
+                entries.push({ relativePath, kind: 'directory', size: 0, digest: '' });
+                visit(absolute, relativePath);
+            }
+            else if (entry.isFile()) {
+                const digest = createHash('sha256').update(fs.readFileSync(absolute)).digest('hex');
+                entries.push({ relativePath, kind: 'file', size: stat.size, digest });
+            }
+            else {
+                throw new Error(`unsupported lifecycle directory entry: ${relativePath}`);
+            }
+        }
+    };
+    visit(root);
+    return entries;
+}
+function copyDirectoryVerified(source, target) {
+    if (fs.existsSync(target))
+        throw new Error(`target directory already exists: ${target}`);
+    const copy = (currentSource, currentTarget) => {
+        fs.mkdirSync(currentTarget);
+        for (const entry of fs.readdirSync(currentSource, { withFileTypes: true })) {
+            const sourcePath = path.join(currentSource, entry.name);
+            const targetPath = path.join(currentTarget, entry.name);
+            const stat = fs.lstatSync(sourcePath);
+            if (stat.isSymbolicLink())
+                throw new Error(`symbolic link is not allowed in lifecycle directory: ${entry.name}`);
+            if (entry.isDirectory())
+                copy(sourcePath, targetPath);
+            else if (entry.isFile())
+                fs.copyFileSync(sourcePath, targetPath);
+            else
+                throw new Error(`unsupported lifecycle directory entry: ${entry.name}`);
+        }
+    };
+    copy(source, target);
+    const sourceManifest = directoryManifest(source);
+    const targetManifest = directoryManifest(target);
+    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
+        throw new Error('copied lifecycle directory failed manifest verification');
+    }
+}
+function removeCopiedSource(source, target) {
+    const sourceManifest = directoryManifest(source);
+    const targetManifest = directoryManifest(target);
+    if (JSON.stringify(sourceManifest) !== JSON.stringify(targetManifest)) {
+        throw new Error('lifecycle source and target diverged before source cleanup');
+    }
+    fs.rmSync(source, { recursive: true, force: false });
+}
 function applyTaskLifecycle(requestInput, options = {}) {
     const normalized = normalizedRequest(requestInput);
     if ('code' in normalized)
@@ -351,7 +416,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     if (!spec.sources.includes(sourceState) && !existingJournal && !allowsManualOverride(options, 'LIFECYCLE_SOURCE_INVALID')) {
         return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (sourcePath !== targetPath && fs.existsSync(targetPath)) {
+    if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal) {
         return failed(request, { code: 'LIFECYCLE_TARGET_CONFLICT', message: `target directory already exists: ${targetPath}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     const content = io.readFileSync(currentTaskFile);
@@ -366,6 +431,11 @@ function applyTaskLifecycle(requestInput, options = {}) {
         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)
@@ -394,6 +464,9 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         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 });
@@ -411,6 +484,9 @@ function applyTaskLifecycle(requestInput, options = {}) {
         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'));
@@ -485,18 +561,55 @@ function applyTaskLifecycle(requestInput, options = {}) {
             (options.directoryRenameSync ?? io.renameSync)(sourcePath, targetPath);
         }
         catch (error) {
-            const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
-            rememberJournalFailure(journalPath, journal, io, failure);
-            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            if (error.code === 'EXDEV') {
+                try {
+                    copyDirectoryVerified(sourcePath, targetPath);
+                    completed.add('directory-moved');
+                    journal.completedSteps = [...completed];
+                    const copiedJournalPath = path.join(targetPath, '.task-lifecycle.json');
+                    writeJournal(initialJournalPath, journal, io);
+                    writeJournal(copiedJournalPath, journal, io);
+                    removeCopiedSource(sourcePath, targetPath);
+                    journalPath = copiedJournalPath;
+                }
+                catch (copyError) {
+                    if (fs.existsSync(targetPath))
+                        fs.rmSync(targetPath, { recursive: true, force: false });
+                    const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(copyError) };
+                    rememberJournalFailure(initialJournalPath, journal, io, failure);
+                    return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+                }
+            }
+            else {
+                const failure = { code: 'LIFECYCLE_DIRECTORY_RENAME_FAILED', message: String(error) };
+                rememberJournalFailure(journalPath, journal, io, failure);
+                return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            }
         }
-        completed.add('directory-moved');
-        journal.completedSteps = [...completed];
-        journalPath = path.join(targetPath, '.task-lifecycle.json');
+        if (completed.has('directory-moved') && !fs.existsSync(sourcePath)) {
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
+        }
+        else if (!completed.has('directory-moved')) {
+            completed.add('directory-moved');
+            journal.completedSteps = [...completed];
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
+            try {
+                writeJournal(journalPath, journal, io);
+            }
+            catch (error) {
+                return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            }
+        }
+    }
+    if (completed.has('directory-moved') && sourcePath !== targetPath && fs.existsSync(sourcePath) && fs.existsSync(targetPath)) {
         try {
-            writeJournal(journalPath, journal, io);
+            removeCopiedSource(sourcePath, targetPath);
+            journalPath = path.join(targetPath, '.task-lifecycle.json');
         }
         catch (error) {
-            return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, directory: { effect: 'move', changed: true }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
+            const failure = { code: 'LIFECYCLE_DIRECTORY_COPY_FAILED', message: String(error) };
+            rememberJournalFailure(journalPath, journal, io, failure);
+            return failed(request, failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         }
     }
     let shortId = { effect: 'unchanged', shortId: null, changed: false };

package/dist/lib/task/orchestration.js

@@ -2,20 +2,22 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { parseReviewSummary } from './review-artifacts.js';
+import { validateCurrentTaskContract } from './current-contract.js';
+import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
 import { inspectArtifactDirectory } 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 { resolveTaskRef } from './resolve-ref.js';
 import { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
 import { resolveAgentRuntimeStoreRoot } from '../runtime/agent-runtime.js';
-import { inspectPlatformPullRequest } from '../platform/pull-requests.js';
 import { getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { hasActiveCodexLifecycleEvidence } from '../agent-clients/adapters/codex-lifecycle/store.js';
+import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.js';
+import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -105,9 +107,8 @@ function isCompletionEvidence(value) {
         && exactText(value.headTree)
         && exactText(value.worktreeTree)
         && exactText(value.lastReviewedCommit)
-        && Number.isSafeInteger(value.prNumber)
-        && value.prNumber > 0
-        && exactText(value.prHead);
+        && (value.prNumber === null || (Number.isSafeInteger(value.prNumber) && value.prNumber > 0))
+        && (value.prHead === null || exactText(value.prHead));
 }
 const ORCHESTRATION_RUN_KEYS = [
     'taskId', 'runId', 'status', 'nextStage', 'stepCount', 'maxSteps', 'modelPolicy',
@@ -339,6 +340,43 @@ function highestRound(taskDir, family) {
 function artifactName(family, round) {
     return round === 1 ? `${family}.md` : `${family}-r${round}.md`;
 }
+function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead) {
+    const reviewRound = highestRound(taskDir, 'review-code');
+    const reviewContent = fs.readFileSync(path.join(taskDir, artifactName('review-code', reviewRound)), 'utf8');
+    const savedTargetHead = extractReviewTargetHead(reviewContent);
+    const savedDiffBase = extractReviewDiffBase(reviewContent);
+    const savedReviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
+    if (!savedTargetHead && !savedDiffBase && !savedReviewedHead)
+        return null;
+    if (savedReviewedHead && savedReviewedHead !== reviewedHead) {
+        return { code: 'ORCHESTRATION_REVIEWED_HEAD_MISMATCH', message: 'review-code saved reviewed head does not match last_reviewed_commit' };
+    }
+    if (!savedTargetHead || !savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_INVALID', message: 'review-code must save target head and diff base together' };
+    }
+    const savedBase = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
+    if (!savedBase.ok)
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_INVALID', message: savedBase.message };
+    if (savedBase.diffBase !== savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_DIFF_BASE_MISMATCH', message: 'saved review diff base does not match reviewed head and saved target head' };
+    }
+    const target = resolveDeliveryTarget(repoRoot, {
+        remote: typeof metadata.delivery_remote === 'string' ? metadata.delivery_remote : undefined,
+        baseRef: typeof metadata.delivery_base_ref === 'string' ? metadata.delivery_base_ref : undefined
+    });
+    if (!target.ok)
+        return { code: target.code, message: target.message };
+    const currentTarget = resolveTargetHead(repoRoot, target.value);
+    if (!currentTarget.ok)
+        return { code: currentTarget.code, message: currentTarget.message };
+    const currentBase = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head);
+    if (!currentBase.ok)
+        return { code: currentBase.code, message: currentBase.message };
+    if (currentBase.diffBase !== savedDiffBase) {
+        return { code: 'ORCHESTRATION_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
+    }
+    return null;
+}
 function hasReviewAfterArtifact(taskDir, family, reviewFamily) {
     const artifact = inspectArtifactDirectory(taskDir, family);
     const review = inspectArtifactDirectory(taskDir, reviewFamily);
@@ -350,9 +388,21 @@ function hasReviewAfterArtifact(taskDir, family, reviewFamily) {
 function latestReviewApproved(taskDir, family) {
     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;
+        return { approved: false, error: null };
+    let content;
+    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) {
     const analysisRound = highestRound(taskDir, 'analysis');
@@ -369,7 +419,10 @@ function routeFromFacts(taskDir) {
         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) };
     }
@@ -381,7 +434,10 @@ function routeFromFacts(taskDir) {
         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) };
     }
@@ -393,7 +449,10 @@ function routeFromFacts(taskDir) {
         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) };
     }
@@ -418,13 +477,25 @@ function routeOrchestration(taskRef, options = {}) {
         return failed('ORCHESTRATION_TASK_READ_FAILED', String(error), resolved.taskId);
     }
     let metadata;
-    try {
-        metadata = parseTypedTaskFrontmatter(content);
+    let currentLedger = 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;
     }
-    catch (error) {
-        return failed('ORCHESTRATION_TASK_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    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);
@@ -440,7 +511,10 @@ function routeOrchestration(taskRef, options = {}) {
         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);
@@ -450,29 +524,8 @@ function routeOrchestration(taskRef, options = {}) {
         if (run?.status === 'completed') {
             return { status: 'completed', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
-        let config;
-        try {
-            config = JSON.parse(fs.readFileSync(path.join(resolved.repoRoot, '.agents', '.airc.json'), 'utf8'));
-        }
-        catch (error) {
-            return failed('ORCHESTRATION_CONFIG_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
-        }
-        if (!config || typeof config !== 'object' || Array.isArray(config)) {
-            return failed('ORCHESTRATION_CONFIG_INVALID', 'project configuration must be an object', resolved.taskId);
-        }
-        const projectConfig = config;
-        if (!Object.hasOwn(projectConfig, 'prFlow') || projectConfig.prFlow === 'disabled') {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
-        }
-        if (projectConfig.prFlow !== 'required') {
-            return failed('ORCHESTRATION_CONFIG_INVALID', "project configuration 'prFlow' must be 'required' or 'disabled'", resolved.taskId);
-        }
-        const prNumber = Number(metadata.pr_number);
-        if (!Number.isInteger(prNumber) || prNumber <= 0) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
-        }
         if (!run) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         if (run.status !== 'running' || run.pendingDelegation !== null) {
             return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'clean completion requires an idle running orchestration', resolved.taskId);
@@ -486,34 +539,15 @@ function routeOrchestration(taskRef, options = {}) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
         }
         if (before.headTree !== before.worktreeTree) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         const lastReviewedCommit = String(metadata.last_reviewed_commit ?? '');
         if (before.head !== lastReviewedCommit) {
             return failed('ORCHESTRATION_REVIEWED_HEAD_MISMATCH', 'local HEAD does not match last_reviewed_commit', resolved.taskId);
         }
-        const inspect = options.inspectPullRequest ?? inspectPlatformPullRequest;
-        let inspection;
-        try {
-            inspection = inspect(resolved.taskId, { cwd: gitRoot });
-        }
-        catch (error) {
-            return failed('ORCHESTRATION_PR_INSPECTION_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
-        }
-        if (inspection.status === 'blocked') {
-            return failed('ORCHESTRATION_PR_INSPECTION_BLOCKED', inspection.error?.message ?? 'pull request inspection is blocked', resolved.taskId);
-        }
-        if (inspection.status === 'failed') {
-            return failed('ORCHESTRATION_PR_INSPECTION_FAILED', inspection.error?.message ?? 'pull request inspection failed', resolved.taskId);
-        }
-        const inspectedPrNumber = inspection.task?.prNumber ?? inspection.prNumber;
-        const prHead = inspection.pullRequest?.head?.sha;
-        if (typeof prHead !== 'string') {
-            return failed('ORCHESTRATION_PR_INSPECTION_INVALID', 'pull request inspection returned incomplete identity evidence', resolved.taskId);
-        }
-        if (inspectedPrNumber !== prNumber || prHead !== before.head) {
-            return failed('ORCHESTRATION_PR_HEAD_MISMATCH', 'pull request identity does not match the reviewed local HEAD', resolved.taskId);
-        }
+        const diffBaseError = validateSavedCurrentDiffBase(resolved.repoRoot, metadata, resolved.taskDir, lastReviewedCommit);
+        if (diffBaseError)
+            return failed(diffBaseError.code, diffBaseError.message, resolved.taskId);
         let after;
         try {
             after = capture(gitRoot);
@@ -522,7 +556,7 @@ function routeOrchestration(taskRef, options = {}) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
         }
         if (after.headTree !== after.worktreeTree) {
-            return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
+            return { status: 'running', changed: false, taskId: resolved.taskId, run, next: null, error: null };
         }
         if (after.head !== before.head || after.headTree !== before.headTree) {
             return failed('ORCHESTRATION_REPOSITORY_CHANGED', 'repository changed while clean completion evidence was collected', resolved.taskId);
@@ -535,8 +569,8 @@ function routeOrchestration(taskRef, options = {}) {
             headTree: after.headTree,
             worktreeTree: after.worktreeTree,
             lastReviewedCommit,
-            prNumber,
-            prHead
+            prNumber: null,
+            prHead: null
         };
         const completed = withUpdatedRun(run, {
             status: 'completed',
@@ -631,10 +665,7 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     const updated = withUpdatedRun(run, {
         nextStage: next.stage,
-        pendingDelegation: receipt,
-        commitAuthorization: next.stage === 'commit' && run.commitAuthorization.issuedAt === null
-            ? { issuedAt: (options.now ?? (() => new Date().toISOString()))(), consumedAt: null }
-            : run.commitAuthorization
+        pendingDelegation: receipt
     });
     saveRun(resolved.taskDir, updated);
     return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next, error: null };
@@ -1056,16 +1087,15 @@ function advanceOrchestration(taskRef, options = {}) {
     const result = consumeDelegation(run.pendingDelegation, { now: options.now });
     if (!result.ok)
         return pauseOrchestration(taskRef, result.code, result.message, true, options);
-    const completed = result.receipt.stage === 'commit';
+    if (result.receipt.stage === 'commit') {
+        return failed('ORCHESTRATED_COMMIT_REMOVED', 'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task', resolved.taskId);
+    }
     const updated = withUpdatedRun(run, {
-        status: completed ? 'completed' : 'running',
+        status: 'running',
         nextStage: null,
         stepCount: run.stepCount + 1,
         pendingDelegation: null,
-        receipts: Object.freeze([...run.receipts, result.receipt]),
-        commitAuthorization: completed
-            ? { ...run.commitAuthorization, consumedAt: (options.now ?? (() => new Date().toISOString()))() }
-            : run.commitAuthorization
+        receipts: Object.freeze([...run.receipts, result.receipt])
     });
     saveRun(resolved.taskDir, updated);
     return { status: updated.status, changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };