@fitlab-ai/agent-infra 0.9.14 → 0.10.0

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';
@@ -108,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));
@@ -208,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);
@@ -225,11 +218,11 @@ 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)
@@ -237,7 +230,7 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         const qualificationStaleArtifacts = [];
         if (qualification.qualification.present) {
             const constraints = new Map(qualification.qualification.constraints.map((row) => [row.constraintId, row.digest]));
-            for (const family of Object.keys(artifactFamilies)) {
+            for (const family of artifactFamilies) {
                 if (!ARTIFACT_AUDIT_FAMILIES.has(family))
                     continue;
                 const name = latestArtifact(artifacts[family] ?? []);

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');
@@ -195,6 +181,16 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
+function samePreparedCheckpointIdentity(pending, identity) {
+    return pending.state === 'prepared'
+        && pending.taskId === identity.taskId
+        && pending.branch === identity.branch
+        && pending.mode === identity.mode
+        && pending.expectedHead === identity.expectedHead
+        && pending.message === identity.message
+        && pending.round === identity.round
+        && JSON.stringify(pending.paths) === JSON.stringify(identity.paths);
+}
 function executeUnlocked(input, task, mode) {
     const inspected = inspectGitWorkflow(input.cwd);
     if (!inspected.snapshot)
@@ -228,11 +224,28 @@ function executeUnlocked(input, task, mode) {
                     error: { code: 'COMMIT_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) }
                 };
             }
-            if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity))
-                return {
-                    status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
-                    error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+            if (pendingIntent && !sameCheckpointIntent(pendingIntent, identity)) {
+                if (!input.recoverPreparedIntent || !samePreparedCheckpointIdentity(pendingIntent, identity))
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_CONFLICT', message: 'A different checkpoint intent is still pending for this task' }
+                    };
+                pendingIntent = {
+                    ...pendingIntent,
+                    expectedTree: identity.expectedTree,
+                    digest: checkpointIntentDigest(identity),
+                    updatedAt: checkpointTimestamp()
                 };
+                try {
+                    writeCheckpointIntent(task.repoRoot, pendingIntent);
+                }
+                catch (error) {
+                    return {
+                        status: 'failed', changed: false, snapshot: inspected.snapshot, operations: [],
+                        error: { code: 'COMMIT_INTENT_WRITE_FAILED', message: error instanceof Error ? error.message : String(error) }
+                    };
+                }
+            }
             if (!pendingIntent) {
                 const timestamp = checkpointTimestamp();
                 pendingIntent = {
@@ -256,7 +269,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' }