@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/task/artifact-schema.js

@@ -0,0 +1,127 @@
+import { parseArtifactName } from './artifact-name.js';
+const LOCAL_SECTIONS = {
+    analysis: [
+        ['source', '需求来源', 'Requirements Source'],
+        ['understanding', '需求理解', 'Requirements Understanding'],
+        ['files', '相关文件', 'Related Files'],
+        ['impact', '影响评估', 'Impact Assessment'],
+        ['risks', '技术风险', 'Technical Risks'],
+        ['effort', '工作量和复杂度评估', 'Effort and Complexity Assessment'],
+        ['state-check', '状态核对', 'State Check']
+    ],
+    plan: [
+        ['understanding', '问题理解', 'Problem Understanding'],
+        ['constraints', '约束条件', 'Constraints'],
+        ['options', '方案对比', 'Options Comparison'],
+        ['approach', '技术方法', 'Technical Approach'],
+        ['steps', '实施步骤', 'Implementation Steps'],
+        ['files', '文件清单', 'File List'],
+        ['verification', '验证策略', 'Verification Strategy'],
+        ['state-check', '状态核对', 'State Check']
+    ],
+    code: [
+        ['input', '实现输入', 'Implementation Input'],
+        ['files', '变更文件', 'Changed Files'],
+        ['key-code', '关键代码说明', 'Key Code Notes'],
+        ['tests', '测试结果', 'Test Results'],
+        ['deviations', '与方案的差异', 'Differences from Plan'],
+        ['review-focus', '供审查关注的内容', 'Review Focus'],
+        ['state-check', '状态核对', 'State Check'],
+        ['evidence', '证据原文', 'Raw Evidence']
+    ],
+    'review-analysis': [
+        ['summary', '审查摘要', 'Review Summary'],
+        ['coverage', '检视覆盖声明', 'Inspection Coverage'],
+        ['specialized-coverage', '需求分析专项覆盖', 'Requirements Analysis Coverage'],
+        ['traceability', '追踪矩阵', 'Traceability Matrix'],
+        ['issues', '问题清单', 'Findings'],
+        ['non-blocking', '非阻塞建议', 'Non-blocking Suggestions'],
+        ['manual-validation', '人工校验项', 'Manual Validation Items'],
+        ['conclusion', '结论与建议', 'Conclusion and Recommendation'],
+        ['state-check', '状态核对', 'State Check'],
+        ['evidence', '证据原文', 'Raw Evidence'],
+        ['self-critique', '自我质疑', 'Self-critique'],
+        ['ledger-writeback', '审查分歧账本回写', 'Review Disagreement Ledger Write-back']
+    ],
+    'review-plan': [
+        ['summary', '审查摘要', 'Review Summary'],
+        ['coverage', '检视覆盖声明', 'Inspection Coverage'],
+        ['specialized-coverage', '技术方案架构覆盖', 'Technical Plan Architecture Coverage'],
+        ['traceability', '追踪矩阵', 'Traceability Matrix'],
+        ['issues', '问题清单', 'Findings'],
+        ['non-blocking', '非阻塞建议', 'Non-blocking Suggestions'],
+        ['manual-validation', '人工校验项', 'Manual Validation Items'],
+        ['conclusion', '结论与建议', 'Conclusion and Recommendation'],
+        ['state-check', '状态核对', 'State Check'],
+        ['evidence', '证据原文', 'Raw Evidence'],
+        ['self-critique', '自我质疑', 'Self-critique'],
+        ['ledger-writeback', '审查分歧账本回写', 'Review Disagreement Ledger Write-back']
+    ],
+    'review-code': [
+        ['summary', '审查摘要', 'Review Summary'],
+        ['coverage', '检视覆盖声明', 'Inspection Coverage'],
+        ['specialized-coverage', '代码实现专项覆盖', 'Code Implementation Coverage'],
+        ['traceability', '追踪矩阵', 'Traceability Matrix'],
+        ['issues', '问题清单', 'Findings'],
+        ['non-blocking', '非阻塞建议', 'Non-blocking Suggestions'],
+        ['manual-validation', '人工校验项', 'Manual Validation Items'],
+        ['conclusion', '结论与建议', 'Conclusion and Recommendation'],
+        ['state-check', '状态核对', 'State Check'],
+        ['evidence', '证据原文', 'Raw Evidence'],
+        ['self-critique', '自我质疑', 'Self-critique'],
+        ['ledger-writeback', '审查分歧账本回写', 'Review Disagreement Ledger Write-back']
+    ]
+};
+function buildSections(family) {
+    return LOCAL_SECTIONS[family].map(([id, zh, en], index) => ({
+        id,
+        order: index + 1,
+        headings: { zh, en },
+        marker: `artifact-section:${family}:${id}`
+    }));
+}
+const ARTIFACT_SCHEMAS = [
+    { family: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), requiredPatterns: ['^\\$ '] },
+    { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
+    { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), requiredPatterns: ['^\\$ '] },
+    { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
+    { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), requiredPatterns: ['^\\$ '] },
+    { family: 'review-code', title: { zh: '代码审查报告', en: 'Code Review Report' }, sections: buildSections('review-code'), requiredPatterns: [
+            '^### (?:审查决定|Approval Decision)$',
+            '^\\$ ',
+            '^- \\*\\*(?:总体结论|Overall Verdict)\\*\\*[:：]\\s*(?:通过|需要修改|拒绝|Approved|Changes Requested|Rejected)\\s*$',
+            '^- \\*\\*(?:审查基线提交|Review Baseline Commit)\\*\\*[:：]\\s*\\S',
+            '^- \\*\\*(?:审查差异基线|Reviewed Diff Base)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$',
+            '^- \\*\\*(?:审查差异指纹|Reviewed Diff Fingerprint)\\*\\*[:：]\\s*sha256:[0-9a-f]{64}\\s*$',
+            '^- \\*\\*(?:审查快照树|Reviewed Snapshot Tree)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$'
+        ] }
+];
+function getArtifactSchema(family) {
+    return ARTIFACT_SCHEMAS.find((schema) => schema.family === family) ?? null;
+}
+function renderArtifactSkeleton(input) {
+    const schema = getArtifactSchema(input.family);
+    if (!schema)
+        throw new Error(`unknown artifact schema family '${input.family}'`);
+    const locale = input.locale ?? 'zh-CN';
+    const identity = parseArtifactName(input.artifact);
+    if (identity?.family !== input.family)
+        throw new Error(`invalid artifact identity '${input.artifact}' for '${input.family}'`);
+    const round = identity.round;
+    const title = schema.title[locale === 'en' ? 'en' : 'zh'];
+    const headings = locale === 'en' ? 'en' : 'zh';
+    const lines = [
+        `<!-- artifact-context:${input.taskId}:${input.family}:${round} -->`,
+        `# ${title}`,
+        ''
+    ];
+    for (const section of schema.sections) {
+        lines.push(`## ${section.headings[headings]}`);
+        lines.push(`<!-- ${section.marker} -->`);
+        lines.push('<!-- artifact-slot:empty -->');
+        lines.push('');
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export { ARTIFACT_SCHEMAS, getArtifactSchema, renderArtifactSkeleton };
+//# sourceMappingURL=artifact-schema.js.map

package/dist/lib/task/capabilities.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { parseArtifactName } from './artifact-name.js';
 import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from './invalidation.js';
 import { receiptForOutput } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
@@ -8,6 +9,8 @@ import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.
 import { parseReworkIntentDocument } from './rework-intent.js';
 import { sha256File } from './artifact-receipts.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
+import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
+const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 const REASONS = new Set([
     'user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'
 ]);
@@ -42,6 +45,9 @@ function canStart(action, facts, trigger) {
         return deny('TASK_NOT_ACTIVE', `state=${facts.taskState}`);
     if (invalidationBlocks(facts.invalidation))
         return deny('INVALIDATION_INCOMPLETE');
+    if (facts.qualificationStale && facts.recommendedAction !== action) {
+        return deny('QUALIFICATION_STALE', ...(facts.qualificationStaleArtifacts ?? ['qualification audit is stale']));
+    }
     if (facts.executionBusy)
         return deny('EXECUTION_BUSY');
     const implicit = trigger.explicitRequest === false;
@@ -103,12 +109,9 @@ function canStart(action, facts, trigger) {
     }
     return deny('CAPABILITY_ACTION_UNKNOWN');
 }
-function artifactRound(name) {
-    const match = /-r(\d+)\.md$/.exec(name);
-    return match ? Number(match[1]) : 1;
-}
 function latestArtifact(names) {
-    return [...names].sort((left, right) => artifactRound(right) - artifactRound(left) || left.localeCompare(right))[0] ?? null;
+    return names.map(parseArtifactName).filter((identity) => identity !== null)
+        .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0]?.name ?? null;
 }
 function reviewedInputName(content, expectedFamily) {
     const header = content.split(/\r?\n/).findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
@@ -122,9 +125,37 @@ function reviewMatchesLatest(facts, source, review) {
     const latestSource = latestArtifact(facts.artifacts[source] ?? []);
     return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
 }
+function qualificationCandidateSnapshotMatches(audit, qualification) {
+    const current = new Map(qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
+    return audit.candidateQualifications.length === current.size && audit.candidateQualifications.every((row) => {
+        const candidate = current.get(row.candidateId);
+        return Boolean(candidate && candidate.status === row.status && candidate.impact === row.impact
+            && candidate.evidence === row.evidence && candidate.constraintIds.join(',') === row.constraintIds.join(','));
+    });
+}
+const QUALIFICATION_RECOVERY_ORDER = [
+    { action: 'analysis', pattern: /^analysis(?:-r\d+)?\.md$/ },
+    { action: 'review-analysis', pattern: /^review-analysis(?:-r\d+)?\.md$/ },
+    { action: 'plan', pattern: /^plan(?:-r\d+)?\.md$/ },
+    { action: 'review-plan', pattern: /^review-plan(?:-r\d+)?\.md$/ },
+    { action: 'code', pattern: /^code(?:-r\d+)?\.md$/ },
+    { action: 'review-code', pattern: /^review-code(?:-r\d+)?\.md$/ }
+];
+function qualificationRecoveryAction(facts) {
+    const stale = facts.qualificationStaleArtifacts ?? [];
+    return QUALIFICATION_RECOVERY_ORDER.find(({ pattern }) => stale.some((name) => pattern.test(name)))?.action ?? null;
+}
 function recommendNext(facts) {
     if (invalidationBlocks(facts.invalidation))
         return { action: null, reasonCode: 'INVALIDATION_INCOMPLETE', evidence: ['reconcile task invalidation before routing'] };
+    if (facts.qualificationStale) {
+        const action = qualificationRecoveryAction(facts);
+        return {
+            action,
+            reasonCode: 'QUALIFICATION_RECOVERY_REQUIRED',
+            evidence: facts.qualificationStaleArtifacts ?? ['qualification audit is stale']
+        };
+    }
     const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
     if (pendingIntent)
         return { action: pendingIntent.target, reasonCode: 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
@@ -175,16 +206,11 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             const stat = fs.lstatSync(path.join(taskDir, name));
             return stat.isFile() && !stat.isSymbolicLink();
         });
-        const artifactFamilies = {
-            analysis: /^analysis(?:-r\d+)?\.md$/,
-            'review-analysis': /^review-analysis(?:-r\d+)?\.md$/,
-            plan: /^plan(?:-r\d+)?\.md$/,
-            'review-plan': /^review-plan(?:-r\d+)?\.md$/,
-            code: /^code(?:-r\d+)?\.md$/,
-            'review-code': /^review-code(?:-r\d+)?\.md$/
+        const artifactFamilies = ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'];
+        const familyFor = (name) => {
+            const family = parseArtifactName(name)?.family;
+            return artifactFamilies.find((candidate) => candidate === family) ?? null;
         };
-        const familyFor = (name) => Object.keys(artifactFamilies)
-            .find((family) => artifactFamilies[family].test(name)) ?? null;
         const activeFiles = files.filter((name) => {
             const family = familyFor(name);
             return !family || !isArtifactInvalidated(invalidation.document, family, name);
@@ -192,12 +218,46 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         const artifactHashes = {};
         for (const name of activeFiles)
             artifactHashes[name] = sha256File(path.join(taskDir, name));
-        const artifacts = Object.fromEntries(Object.keys(artifactFamilies).map((family) => [
-            family, activeFiles.filter((name) => artifactFamilies[family].test(name))
+        const artifacts = Object.fromEntries(artifactFamilies.map((family) => [
+            family, activeFiles.filter((name) => familyFor(name) === family)
         ]));
-        const staleArtifacts = Object.fromEntries(Object.keys(artifactFamilies).map((family) => [
-            family, files.filter((name) => artifactFamilies[family].test(name) && isArtifactInvalidated(invalidation.document, family, name))
+        const staleArtifacts = Object.fromEntries(artifactFamilies.map((family) => [
+            family, files.filter((name) => familyFor(name) === family && isArtifactInvalidated(invalidation.document, family, name))
         ]));
+        const qualification = parseTaskQualification(content);
+        if (!qualification.ok)
+            return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: qualification.message };
+        const qualificationStaleArtifacts = [];
+        if (qualification.qualification.present) {
+            const constraints = new Map(qualification.qualification.constraints.map((row) => [row.constraintId, row.digest]));
+            for (const family of artifactFamilies) {
+                if (!ARTIFACT_AUDIT_FAMILIES.has(family))
+                    continue;
+                const name = latestArtifact(artifacts[family] ?? []);
+                if (!name)
+                    continue;
+                let auditContent;
+                try {
+                    auditContent = fs.readFileSync(path.join(taskDir, name), 'utf8');
+                }
+                catch {
+                    qualificationStaleArtifacts.push(name);
+                    continue;
+                }
+                const audit = parseQualificationAudit(auditContent);
+                if (!audit.ok || !audit.audit.present || !audit.audit.snapshot) {
+                    qualificationStaleArtifacts.push(name);
+                    continue;
+                }
+                const constraintsChanged = audit.audit.constraintDependencies.some((dependency) => constraints.get(dependency.constraintId) !== dependency.constraintDigest);
+                const taskInputChanged = audit.audit.snapshot.taskInputDigest !== qualification.qualification.taskInputDigest;
+                if (audit.audit.snapshot.nonConstraintInputDigest !== qualification.qualification.nonConstraintInputDigest
+                    || constraintsChanged
+                    || (taskInputChanged && !constraintsChanged)
+                    || (taskInputChanged && !qualificationCandidateSnapshotMatches(audit.audit, qualification.qualification)))
+                    qualificationStaleArtifacts.push(name);
+            }
+        }
         const reviews = {};
         const reviewedInputs = {};
         for (const family of ['review-analysis', 'review-plan', 'review-code']) {
@@ -226,7 +286,11 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
             staleArtifacts, reviewedInputs, artifactHashes,
             invalidation: invalidation.document, reworkIntents: rework.intents,
-            unresolvedLedger, executionBusy: executionBusy || hasOpenLifecycleExecution(content), recommendedAction: null
+            unresolvedLedger,
+            executionBusy: executionBusy || hasOpenLifecycleExecution(content),
+            recommendedAction: null,
+            qualificationStale: qualificationStaleArtifacts.length > 0,
+            qualificationStaleArtifacts
         };
         facts.recommendedAction = recommendNext(facts).action;
         return { ok: true, facts };

package/dist/lib/task/codex-orchestration.js

@@ -5,7 +5,12 @@ import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from '../
 import { verifyCodexSandboxControllerContextWithWarnings as verifySandboxControllerWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
 import { verifyCodexSandboxControllerContextWithWarnings as verifyControllerContextFileWithWarnings } from '../agent-clients/adapters/codex-lifecycle/controller-context.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, routeOrchestration, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
+import { randomUUID, createHash } from 'node:crypto';
+import { consumeLifecycleRecoveryAttestation, issueLifecycleRecoveryAttestation, validateLifecycleRecoveryAttestation } from './control-authority.js';
+function buildIdentityDigest(value) {
+    return createHash('sha256').update(JSON.stringify(value), 'utf8').digest('hex');
+}
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
@@ -73,8 +78,9 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
         if (!resolved.ok)
             return bridgeFailure(resolved.code, resolved.message);
         const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
-        if (!input.capabilityToken) {
-            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability token');
+        const capabilityRef = input.capabilityRef;
+        if (!capabilityRef) {
+            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability reference');
         }
         const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
         const brokerController = options.controllerBinding ?? brokerControllerBinding();
@@ -99,7 +105,7 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
             controlGeneration: localController.controlGeneration
         } : null);
         const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
-        const attested = capabilityStore.inspect(input.capabilityToken);
+        const attested = capabilityStore.inspectReference(capabilityRef);
         const capabilityIdentity = verifyLifecycleBuildIdentity(attested.buildIdentity, buildIdentity);
         if (!capabilityIdentity.ok) {
             return bridgeFailure(capabilityIdentity.code, capabilityIdentity.message);
@@ -124,14 +130,57 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
                     controlGeneration: controller.controlGeneration
                 } } : {})
         };
+        if (input.lifecycleRecoveryAttestation) {
+            try {
+                validateLifecycleRecoveryAttestation(input.lifecycleRecoveryAttestation);
+            }
+            catch (error) {
+                return bridgeFailure('LIFECYCLE_AUTHORITY_ATTESTATION_INVALID', error instanceof Error ? error.message : String(error));
+            }
+        }
+        let lifecycleRecoveryAttestation = input.lifecycleRecoveryAttestation ?? null;
+        const routed = input.capabilityRef && !lifecycleRecoveryAttestation
+            ? routeOrchestration(taskRef, coreOptions(options))
+            : null;
+        if (routed && !routed.next)
+            return routed;
+        if (routed?.next && ['analysis', 'plan', 'code'].includes(routed.next.stage)) {
+            const recoveryRequest = {
+                version: 1,
+                requestId: randomUUID(),
+                operationId: randomUUID(),
+                phase: 'orchestration.prepare',
+                taskId: resolved.taskId,
+                family: routed.next.stage === 'analysis' ? 'analysis'
+                    : routed.next.stage === 'plan' ? 'plan' : 'code',
+                artifact: routed.next.artifact,
+                round: routed.next.round,
+                lifecycleRequestId: randomUUID(),
+                authorityRef: capabilityRef,
+                expectedControlGeneration: controller?.controlGeneration ?? '',
+                expectedControllerInstanceDigest: controller?.instanceDigest ?? '0'.repeat(64),
+                expectedBuildIdentityDigest: buildIdentityDigest(buildIdentity),
+                expectedHookDefinitionHash: preflight.hookDefinitionHash
+            };
+            const authority = issueLifecycleRecoveryAttestation(recoveryRequest, {
+                capabilityStore,
+                ...(controller ? { controllerBinding: controller } : {}),
+                buildIdentity
+            });
+            if (authority.status === 'rejected' || !authority.attestation) {
+                return bridgeFailure(authority.error?.code ?? 'LIFECYCLE_AUTHORITY_REJECTED', authority.error?.message ?? 'lifecycle authority was rejected');
+            }
+            lifecycleRecoveryAttestation = authority.attestation;
+        }
         const prepared = prepareOrchestrationDelegation(taskRef, {
             ...input,
-            lifecycleProvenance
+            lifecycleProvenance,
+            lifecycleRecoveryAttestation
         }, {
             ...coreOptions(options),
             validateLifecycleCapability: () => {
                 try {
-                    const validated = capabilityStore.validate(input.capabilityToken, capabilityExpected);
+                    const validated = capabilityStore.validateReference(capabilityRef, capabilityExpected);
                     if (validated.sessionId !== attested.sessionId
                         || validated.turnId !== attested.turnId
                         || validated.toolUseId !== attested.toolUseId) {
@@ -146,24 +195,16 @@ async function prepareCodexOrchestrationDelegation(taskRef, input, options = {})
                     return capabilityFailure(error);
                 }
             },
-            consumeLifecycleCapability: () => {
-                try {
-                    const consumed = capabilityStore.consume(input.capabilityToken, capabilityExpected);
-                    if (consumed.sessionId !== attested.sessionId
-                        || consumed.turnId !== attested.turnId
-                        || consumed.toolUseId !== attested.toolUseId) {
-                        return {
-                            code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
-                            message: 'capability identity changed during consumption'
-                        };
-                    }
-                    return null;
-                }
-                catch (error) {
-                    return capabilityFailure(error);
-                }
-            }
+            consumeLifecycleCapability: () => null
         });
+        if (lifecycleRecoveryAttestation && !options.deferLifecycleRecoveryConsumption && prepared.status !== 'failed') {
+            try {
+                consumeLifecycleRecoveryAttestation(lifecycleRecoveryAttestation);
+            }
+            catch (error) {
+                return bridgeFailure(error instanceof Error ? error.name : 'LIFECYCLE_AUTHORITY_CONSUME_FAILED', error instanceof Error ? error.message : String(error));
+            }
+        }
         return identityWarnings.length > 0 && prepared.status !== 'failed'
             ? { ...prepared, warnings: Object.freeze(identityWarnings) }
             : prepared;
@@ -211,7 +252,12 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
         const contextVerification = contextPath
             ? verifySandboxControllerWithWarnings(contextPath, { repoRoot })
             : null;
-        const controller = contextVerification?.context ?? null;
+        const controller = options.controllerBinding
+            ?? brokerControllerBinding()
+            ?? (contextVerification?.context ? {
+                instanceDigest: contextVerification.context.controllerInstanceDigest,
+                controlGeneration: contextVerification.context.controlGeneration
+            } : null);
         const activated = activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
             childId: evidence.childThreadId,
@@ -233,7 +279,7 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                 capabilityTurnId: evidence.parentTurnId,
                 spawnToolUseId: evidence.spawnToolUseId,
                 spawnObservedAt: record.spawnObservedAt ?? undefined,
-                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+                controllerInstanceDigest: controller?.instanceDigest ?? null,
                 controlGeneration: controller?.controlGeneration ?? null
             }
         }, coreOptions(options));

package/dist/lib/task/commit-identity.js

@@ -0,0 +1,28 @@
+import { execFileSync } from 'node:child_process';
+function gitText(repoRoot, args) {
+    return execFileSync('git', [...args], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function checkpointCommitMatches(repoRoot, intent, head) {
+    try {
+        const parent = gitText(repoRoot, ['rev-parse', `${head}^`]);
+        const tree = gitText(repoRoot, ['rev-parse', `${head}^{tree}`]);
+        const message = gitText(repoRoot, ['show', '-s', '--format=%s', head]);
+        const changed = gitText(repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head])
+            .split('\n')
+            .filter(Boolean)
+            .sort();
+        return parent === intent.expectedHead
+            && tree === intent.expectedTree
+            && message === intent.message
+            && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
+    }
+    catch {
+        return false;
+    }
+}
+export { checkpointCommitMatches };
+//# sourceMappingURL=commit-identity.js.map

package/dist/lib/task/commit-operation.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/workflow.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
+import { checkpointCommitMatches } from './commit-identity.js';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.js';
 import { commitPushDecision } from './commit-policy.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
@@ -163,21 +164,6 @@ function syncTaskCommit(input, task, committedHead) {
         return warning('TASK_STATUS_SYNC_FAILED', error instanceof Error ? error.message : String(error), true, 'task', task.taskId, 'ACTION_REQUIRED');
     }
 }
-function checkpointChildMatches(task, intent, head) {
-    try {
-        const parent = gitText(task.repoRoot, ['rev-parse', `${head}^`]);
-        const tree = gitText(task.repoRoot, ['rev-parse', `${head}^{tree}`]);
-        const message = gitText(task.repoRoot, ['show', '-s', '--format=%s', head]);
-        const changed = gitText(task.repoRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', head]).split('\n').filter(Boolean).sort();
-        return parent === intent.expectedHead
-            && tree === intent.expectedTree
-            && message === intent.message
-            && JSON.stringify(changed) === JSON.stringify([...intent.paths].sort());
-    }
-    catch {
-        return false;
-    }
-}
 function checkpointIdentity(input, task, delivery) {
     if (delivery.mode !== 'local')
         throw new Error('checkpoint identity requires local delivery');
@@ -256,7 +242,7 @@ function executeUnlocked(input, task, mode) {
                     operations: [{ name: 'commit', status: 'no-op' }], error: null
                 };
             }
-            if (inspected.snapshot.head !== identity.expectedHead && !checkpointChildMatches(task, pendingIntent, inspected.snapshot.head))
+            if (inspected.snapshot.head !== identity.expectedHead && !checkpointCommitMatches(task.repoRoot, pendingIntent, inspected.snapshot.head))
                 return {
                     status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
                     error: { code: 'COMMIT_INTENT_HEAD_CONFLICT', message: 'Current HEAD does not match the pending checkpoint intent' }