@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/dist/lib/task/capabilities.js

@@ -2,7 +2,7 @@ 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 { parseArtifactReceipts, receiptForOutput } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
@@ -10,6 +10,8 @@ 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';
+import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.js';
+import { parseImplementationInputs } from './implementation-inputs.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'
@@ -23,6 +25,11 @@ function allow(...evidence) {
 function hasArtifact(facts, action) {
     return (facts.artifacts[action]?.length ?? 0) > 0;
 }
+function effectiveReworkTarget(target, pathState) {
+    if (target === 'plan' && pathState?.status === 'valid' && !pathIncludes(pathState, 'plan'))
+        return 'analysis';
+    return target;
+}
 function canStart(action, facts, trigger) {
     if (!trigger || trigger.requestedAction !== action)
         return deny('TRIGGER_ACTION_MISMATCH', `requested=${trigger?.requestedAction ?? 'missing'}`);
@@ -45,11 +52,30 @@ 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 pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
+    if (pendingIntent) {
+        const target = effectiveReworkTarget(pendingIntent.target, facts.pathState);
+        const requirementRestart = action === 'analysis' && trigger.reasonCode === 'new-requirement';
+        if (!requirementRestart && (target === 'pause' || target !== action)) {
+            return deny(target === 'pause' ? 'REWORK_PAUSED' : 'REWORK_INTENT_TARGET_MISMATCH', pendingIntent.intentId);
+        }
+    }
+    if (facts.pathState && facts.pathState.status !== 'valid') {
+        return action === 'analysis'
+            ? allow(`lifecycle-path-${facts.pathState.status}`)
+            : deny('LIFECYCLE_PATH_INVALID', facts.pathState.message);
+    }
+    if (facts.pathState?.status === 'valid'
+        && ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(action)
+        && !pathIncludes(facts.pathState, action)) {
+        return deny('ARTIFACT_STAGE_NOT_SELECTED', `path=${facts.pathState.decision.path}`, `stage=${action}`);
+    }
+    if (facts.reworkClassificationRequired?.includes(action)
+        && !(facts.reworkIntents ?? []).some((intent) => intent.status === 'pending')) {
+        return deny('REWORK_CLASSIFICATION_REQUIRED', `stage=${action}`);
+    }
     const implicit = trigger.explicitRequest === false;
     if (action === 'analysis') {
         if (!implicit || hasArtifact(facts, 'analysis') || facts.recommendedAction === 'analysis')
@@ -60,6 +86,9 @@ function canStart(action, facts, trigger) {
         return hasArtifact(facts, 'analysis') ? allow('analysis-artifact') : deny('ANALYSIS_ARTIFACT_REQUIRED');
     }
     if (action === 'plan') {
+        if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'standard') {
+            return hasArtifact(facts, 'analysis') ? allow('analysis-artifact') : deny('ANALYSIS_ARTIFACT_REQUIRED');
+        }
         if (!hasArtifact(facts, 'review-analysis'))
             return deny('ANALYSIS_REVIEW_REQUIRED');
         if (!reviewMatchesLatest(facts, 'analysis', 'review-analysis'))
@@ -75,6 +104,8 @@ function canStart(action, facts, trigger) {
     }
     if (action === 'code') {
         if (trigger.implementationInput) {
+            if (facts.resolvedHumanDecisions?.code === 'implementation')
+                return allow('human-decision-implementation-input');
             if (!hasArtifact(facts, 'review-code'))
                 return deny('CODE_REVIEW_REQUIRED');
             if (!reviewMatchesLatest(facts, 'code', 'review-code'))
@@ -83,6 +114,20 @@ function canStart(action, facts, trigger) {
                 return deny('CODE_REVIEW_NOT_APPROVED');
             return allow('implementation-input');
         }
+        if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'streamlined') {
+            if (!hasArtifact(facts, 'analysis'))
+                return deny('ANALYSIS_ARTIFACT_REQUIRED');
+            if (facts.unresolvedLedger.analysis > 0)
+                return deny('ANALYSIS_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.analysis}`);
+            return allow('analysis-path-approved');
+        }
+        if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'standard') {
+            if (!hasArtifact(facts, 'plan'))
+                return deny('PLAN_ARTIFACT_REQUIRED');
+            if (facts.unresolvedLedger.plan > 0)
+                return deny('PLAN_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.plan}`);
+            return allow('plan-path-approved');
+        }
         if (!hasArtifact(facts, 'review-plan'))
             return deny('PLAN_REVIEW_REQUIRED');
         if (!reviewMatchesLatest(facts, 'plan', 'review-plan'))
@@ -113,14 +158,6 @@ function latestArtifact(names) {
     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));
-    if (header < 0)
-        return null;
-    const referenceBlock = content.split(/\r?\n/).slice(header, header + 12).join('\n');
-    const expected = new RegExp('`' + expectedFamily + '(?:-r[2-9]|-r[1-9]\\d+)?\\.md`');
-    return expected.exec(referenceBlock)?.[0].slice(1, -1) ?? null;
-}
 function reviewMatchesLatest(facts, source, review) {
     const latestSource = latestArtifact(facts.artifacts[source] ?? []);
     return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
@@ -133,30 +170,56 @@ function qualificationCandidateSnapshotMatches(audit, qualification) {
             && 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 (facts.qualificationStale) {
-        const action = qualificationRecoveryAction(facts);
-        return {
-            action,
-            reasonCode: 'QUALIFICATION_RECOVERY_REQUIRED',
-            evidence: facts.qualificationStaleArtifacts ?? ['qualification audit is stale']
-        };
+    if ((facts.reworkClassificationRequired?.length ?? 0) > 0
+        && !(facts.reworkIntents ?? []).some((intent) => intent.status === 'pending')) {
+        return { action: null, reasonCode: 'REWORK_CLASSIFICATION_REQUIRED', evidence: facts.reworkClassificationRequired ?? [] };
     }
     const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
-    if (pendingIntent)
-        return { action: pendingIntent.target, reasonCode: 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
+    if (pendingIntent) {
+        const target = effectiveReworkTarget(pendingIntent.target, facts.pathState);
+        return { action: target === 'pause' ? null : target, reasonCode: target === 'pause' ? 'REWORK_PAUSED' : 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
+    }
+    if (facts.pathState && facts.pathState.status !== 'valid') {
+        return { action: 'analysis', reasonCode: facts.pathState.status === 'missing' ? 'LIFECYCLE_PATH_MISSING' : 'LIFECYCLE_PATH_INVALID', evidence: [facts.pathState.message] };
+    }
+    if (facts.pathState?.status === 'valid') {
+        for (const stage of facts.pathState.decision.stages) {
+            if (stage === 'analysis' && !hasArtifact(facts, stage))
+                return { action: stage, reasonCode: 'ANALYSIS_ARTIFACT_MISSING', evidence: ['analysis artifact is absent'] };
+            if (stage === 'review-analysis' && (!reviewMatchesLatest(facts, 'analysis', stage) || facts.reviews[stage] !== 'approved')) {
+                if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.analysis === 'review') {
+                    return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['analysis decision was resolved'] };
+                }
+                return facts.reviews[stage] === 'changes-requested'
+                    ? { action: 'analysis', reasonCode: 'ANALYSIS_REWORK_REQUIRED', evidence: ['analysis review is not approved'] }
+                    : { action: stage, reasonCode: 'ANALYSIS_REVIEW_MISSING', evidence: ['analysis review does not bind the latest analysis artifact'] };
+            }
+            if (stage === 'plan' && !hasArtifact(facts, stage))
+                return { action: stage, reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+            if (stage === 'review-plan' && (!reviewMatchesLatest(facts, 'plan', stage) || facts.reviews[stage] !== 'approved')) {
+                if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.plan === 'review') {
+                    return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['plan decision was resolved'] };
+                }
+                return facts.reviews[stage] === 'changes-requested'
+                    ? { action: 'plan', reasonCode: 'PLAN_REWORK_REQUIRED', evidence: ['plan review is not approved'] }
+                    : { action: stage, reasonCode: 'PLAN_REVIEW_MISSING', evidence: ['plan review does not bind the latest plan artifact'] };
+            }
+            if (stage === 'code' && !hasArtifact(facts, stage))
+                return { action: stage, reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+            if (stage === 'review-code' && (!reviewMatchesLatest(facts, 'code', stage) || facts.reviews[stage] !== 'approved')) {
+                if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.code) {
+                    return facts.resolvedHumanDecisions.code === 'implementation'
+                        ? { action: 'code', reasonCode: 'HUMAN_DECISION_IMPLEMENTATION_REQUIRED', evidence: ['code decision requires implementation'] }
+                        : { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['code decision requires no implementation'] };
+                }
+                return facts.reviews[stage] === 'changes-requested'
+                    ? { action: 'code', reasonCode: 'CODE_REWORK_REQUIRED', evidence: ['code review is not approved'] }
+                    : { action: stage, reasonCode: 'CODE_REVIEW_MISSING', evidence: ['code review does not bind the latest code artifact'] };
+            }
+        }
+        return { action: null, reasonCode: 'LIFECYCLE_REVIEWED', evidence: ['selected lifecycle path is complete'] };
+    }
     if (!hasArtifact(facts, 'analysis'))
         return { action: 'analysis', reasonCode: 'ANALYSIS_ARTIFACT_MISSING', evidence: ['analysis artifact is absent'] };
     if (!hasArtifact(facts, 'review-analysis') || !reviewMatchesLatest(facts, 'analysis', 'review-analysis')) {
@@ -213,9 +276,12 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             const family = familyFor(name);
             return !family || !isArtifactInvalidated(invalidation.document, family, name);
         });
+        const allArtifactHashes = {};
+        for (const name of files)
+            allArtifactHashes[name] = sha256File(path.join(taskDir, name));
         const artifactHashes = {};
         for (const name of activeFiles)
-            artifactHashes[name] = sha256File(path.join(taskDir, name));
+            artifactHashes[name] = allArtifactHashes[name];
         const artifacts = Object.fromEntries(artifactFamilies.map((family) => [
             family, activeFiles.filter((name) => familyFor(name) === family)
         ]));
@@ -264,9 +330,12 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
                 continue;
             const reviewContent = fs.readFileSync(path.join(taskDir, latest), 'utf8');
             const expectedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
-            const input = reviewedInputName(reviewContent, expectedFamily);
-            const receipt = input ? receiptForOutput(content, latest) : null;
-            if (input && receipt?.input === input && artifactHashes[input] === receipt.inputSha256)
+            const receipt = receiptForOutput(content, latest);
+            const input = receipt?.input;
+            if (input
+                && parseArtifactName(input)?.family === expectedFamily
+                && (artifacts[expectedFamily] ?? []).includes(input)
+                && artifactHashes[input] === receipt.inputSha256)
                 reviewedInputs[family] = input;
             const parsed = parseReviewSummary(reviewContent);
             if (!parsed.ok)
@@ -275,11 +344,58 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             if (verdict.ok)
                 reviews[family] = verdict.verdict === 'Approved' ? 'approved' : verdict.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
         }
+        const reworkClassificationRequired = [];
+        const receipts = parseArtifactReceipts(content).rows;
+        for (const [reviewFamily, stage] of [['review-analysis', 'analysis'], ['review-plan', 'plan'], ['review-code', 'code']]) {
+            const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && files.includes(receipt.output)
+                && allArtifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => {
+                const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, receipt.output), 'utf8'));
+                const verdict = parsed.ok ? resolveCanonicalVerdict(parsed.summary) : null;
+                return {
+                    input: receipt.input,
+                    output: receipt.output,
+                    outputRound: parseArtifactName(receipt.output)?.round ?? 0,
+                    inputRound: parseArtifactName(receipt.input)?.round ?? 0,
+                    verdict: verdict?.ok ? verdict.verdict : null
+                };
+            }).sort((left, right) => left.inputRound - right.inputRound || left.outputRound - right.outputRound || left.output.localeCompare(right.output));
+            const latest = cycles.at(-1);
+            const trailingInputRounds = new Set();
+            for (let index = cycles.length - 1; index >= 0 && cycles[index].verdict === 'Changes Requested'; index -= 1) {
+                trailingInputRounds.add(cycles[index].inputRound);
+            }
+            const handled = latest && (rework.intents ?? []).some((intent) => intent.sourceArtifact === latest.output
+                && intent.sourceSha256 === allArtifactHashes[latest.output]);
+            const latestActiveReview = latestArtifact(artifacts[reviewFamily] ?? []);
+            const latestActiveInput = latestArtifact(artifacts[stage] ?? []);
+            const latestCycleIsActive = latest?.output === latestActiveReview && latest.input === latestActiveInput;
+            if (latestCycleIsActive && latest.verdict === 'Changes Requested' && trailingInputRounds.size >= 2 && !handled)
+                reworkClassificationRequired.push(stage);
+        }
         const unresolvedLedger = { analysis: 0, plan: 0, code: 0 };
         if (ledger.present) {
             for (const stage of ['analysis', 'plan', 'code'])
                 unresolvedLedger[stage] = summarizeLedgerStage(ledger.rows, stage).unresolved.length;
         }
+        const latestAnalysis = latestArtifact(artifacts.analysis ?? []);
+        const pathState = latestAnalysis
+            ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latestAnalysis), 'utf8'), latestAnalysis, artifactHashes[latestAnalysis] ?? '')
+            : { status: 'missing', decision: null, message: 'analysis artifact is missing' };
+        const resolvedHumanDecisions = {};
+        const implementationInputs = parseImplementationInputs(content).rows;
+        for (const stage of ['analysis', 'plan', 'code']) {
+            const reviewFamily = `review-${stage}`;
+            const latestReview = latestArtifact(artifacts[reviewFamily] ?? []);
+            if (!latestReview || reviews[reviewFamily] !== 'changes-requested')
+                continue;
+            const latestHash = artifactHashes[latestReview];
+            const decision = rework.intents.find((intent) => intent.status === 'consumed'
+                && intent.classification === 'human-decision' && intent.sourceArtifact === latestReview && intent.sourceSha256 === latestHash);
+            if (!decision)
+                continue;
+            const implementationInput = implementationInputs.find((input) => input.ledgerId === decision.findingId);
+            resolvedHumanDecisions[stage] = stage === 'code' && implementationInput?.status === 'pending' ? 'implementation' : 'review';
+        }
         const facts = {
             taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
             staleArtifacts, reviewedInputs, artifactHashes,
@@ -288,7 +404,10 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             executionBusy: executionBusy || hasOpenLifecycleExecution(content),
             recommendedAction: null,
             qualificationStale: qualificationStaleArtifacts.length > 0,
-            qualificationStaleArtifacts
+            qualificationStaleArtifacts,
+            pathState,
+            reworkClassificationRequired,
+            resolvedHumanDecisions
         };
         facts.recommendedAction = recommendNext(facts).action;
         return { ok: true, facts };
@@ -297,5 +416,5 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
         return { ok: false, code: 'TASK_CAPABILITY_FACTS_INVALID', message: error instanceof Error ? error.message : String(error) };
     }
 }
-export { buildLifecycleFacts, canStart, recommendNext };
+export { buildLifecycleFacts, canStart, effectiveReworkTarget, recommendNext };
 //# sourceMappingURL=capabilities.js.map

package/dist/lib/task/commands/status.js

@@ -325,7 +325,11 @@ function renderStatus(model) {
         ['processed', `${model.invalidation?.processed ?? 0}/${model.invalidation?.total ?? 0}`],
         ['pending_intents', String(model.invalidation?.pendingIntents ?? 0)]
     ]));
-    lines.push('', 'Recommendation', ...renderPairs([['action', model.recommendation ?? DASH]]));
+    lines.push('', 'Recommendation', ...renderPairs([
+        ['path', model.lifecyclePath ?? DASH],
+        ['action', model.recommendation ?? DASH],
+        ['reason', model.recommendationReason ?? DASH]
+    ]));
     lines.push('', 'Orchestration', ...renderPairs([
         ['status', model.orchestration.status],
         ['run_id', model.orchestration.runId],
@@ -411,7 +415,8 @@ function buildFromResolved(input) {
             pendingIntents
         };
     const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
-    const recommendation = facts.ok ? (recommendNext(facts.facts).action ?? DASH) : DASH;
+    const next = facts.ok ? recommendNext(facts.facts) : null;
+    const recommendation = next?.action ?? DASH;
     return {
         taskId: input.taskId,
         shortId: input.shortId ?? loadShortIdByTaskId(input.repoRoot).get(input.taskId) ?? DASH,
@@ -424,6 +429,8 @@ function buildFromResolved(input) {
         orchestration: collectOrchestration(input.taskDir),
         invalidation: invalidationInfo,
         recommendation,
+        recommendationReason: next?.reasonCode ?? 'TASK_CAPABILITY_FACTS_INVALID',
+        lifecyclePath: facts.ok && facts.facts.pathState?.status === 'valid' ? facts.facts.pathState.decision.path : facts.ok ? facts.facts.pathState?.status ?? DASH : DASH,
         git: collectGit(fm.branch ?? '', run)
     };
 }

package/dist/lib/task/control-authority.js

@@ -1,20 +1,16 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
-import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { getAgentClientAdapter } from '../agent-clients/registry.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, prepareOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from './orchestration.js';
-import { applyTaskFinalization } from './finalization.js';
+import { applyTaskFinalization, commitPreparedTaskFinalization } from './finalization.js';
 import { applyTaskLifecycle, taskLifecycleFailure } from './lifecycle.js';
-import { locateActivityLog } from './activity-log.js';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
-import { findArtifactRecoveryIntentsByOperation, writeArtifactRecoveryIntent } from './artifact-repair-intent.js';
-import { computeLifecycleBuildIdentity, verifyLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
 const lifecycleAuthorityPhases = [
     'orchestration.prepare', 'artifact.finalize-local', 'task-event.completed'
 ];
@@ -184,7 +180,6 @@ export function queryLifecycleRecoveryOperation(operationId, options = {}) {
     const store = options.capabilityStore ?? createCodexCapabilityStore();
     const registry = authorityOperationMap.get(store);
     const known = [...(registry?.values() ?? [])].filter((value) => value.operationId === operationId);
-    const intents = options.repoRoot ? findArtifactRecoveryIntentsByOperation(options.repoRoot, operationId) : [];
     const capabilities = store.findByRecoveryOperation(operationId);
     const phaseMap = new Map();
     for (const capability of capabilities) {
@@ -208,23 +203,10 @@ export function queryLifecycleRecoveryOperation(operationId, options = {}) {
                 ? 'consumed' : 'issued'
         });
     }
-    for (const intent of intents) {
-        if (!intent.phase)
-            continue;
-        const key = `${intent.phase}\0${intent.requestId}`;
-        if (phaseMap.has(key))
-            continue;
-        phaseMap.set(key, {
-            phase: intent.phase,
-            requestId: intent.requestId,
-            attestationId: null,
-            state: intent.state === 'consumed' ? 'consumed' : 'observed'
-        });
-    }
     const capabilityState = capabilities.some((record) => record.recoveryState === 'consumed')
         ? 'consumed'
         : capabilities.some((record) => record.recoveryState === 'reserved') ? 'reserved' : 'unknown';
-    const committed = capabilityState === 'consumed' || intents.some((intent) => intent.state === 'consumed');
+    const committed = capabilityState === 'consumed';
     return {
         version: 1,
         operationId,
@@ -233,120 +215,6 @@ export function queryLifecycleRecoveryOperation(operationId, options = {}) {
         phases: Object.freeze([...phaseMap.values()])
     };
 }
-function lifecycleRecoveryCompensationError(code, message) {
-    const error = new Error(`${code}: ${message}`);
-    error.name = code;
-    return error;
-}
-function lifecycleRecoveryEventCommitted(selector, repoRoot) {
-    const resolved = resolveTaskRef(selector.taskId, { repoRoot });
-    if (!resolved.ok || resolved.taskId !== selector.taskId)
-        return false;
-    let content;
-    try {
-        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    }
-    catch {
-        return false;
-    }
-    const section = locateActivityLog(content);
-    if (!section)
-        return false;
-    const labels = { analysis: 'Analyze Task', plan: 'Plan Task', code: 'Code Task' };
-    const prefix = `${labels[selector.family]} (Round ${selector.round}`;
-    return section.entries.some((entry) => {
-        if (entry.step.endsWith(' [started]') || !entry.step.startsWith(prefix))
-            return false;
-        const delimiter = entry.step[prefix.length];
-        return (delimiter === ',' || delimiter === ')') && entry.note.endsWith(`→ ${selector.artifact}`);
-    });
-}
-function lifecycleRecoveryIntentMatches(intent, selector) {
-    return intent.taskId === selector.taskId
-        && intent.family === selector.family
-        && intent.artifact === selector.artifact
-        && (intent.state === 'commit-started' || intent.state === 'consumption-started' || intent.state === 'consumed');
-}
-/**
- * Completes only the durable tail of a committed task event after a process
- * restart. The task event itself is the commit boundary and is never replayed.
- */
-export function recoverLifecycleRecoveryOperation(input, options) {
-    const selector = validateLifecycleAuthorityRequest(input);
-    if (selector.phase !== 'task-event.completed') {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PHASE_UNSUPPORTED', 'only task-event.completed supports durable compensation');
-    }
-    const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(options.repoRoot);
-    if (selector.expectedBuildIdentityDigest !== lifecycleAuthorityBuildDigest(buildIdentity)) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_AUTHORITY_BUILD_MISMATCH', 'current lifecycle build does not match the recovery request');
-    }
-    if (selector.expectedControlGeneration !== options.controllerBinding.controlGeneration
-        || selector.expectedControllerInstanceDigest !== options.controllerBinding.instanceDigest) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_AUTHORITY_CONTROLLER_MISMATCH', 'current controller binding does not match the recovery request');
-    }
-    const store = options.capabilityStore ?? createCodexCapabilityStore();
-    const expected = {
-        taskId: selector.taskId,
-        hookDefinitionHash: selector.expectedHookDefinitionHash,
-        buildIdentity,
-        controller: options.controllerBinding
-    };
-    const capabilities = store.findByRecoveryOperation(selector.operationId);
-    if (capabilities.length !== 1 || capabilities[0].capabilityRefDigest !== lifecycleAuthorityDigest(selector.authorityRef)) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PROVENANCE_INVALID', 'durable capability provenance does not identify this operation');
-    }
-    const capability = capabilities[0];
-    const build = verifyLifecycleBuildIdentity(capability.buildIdentity, buildIdentity);
-    const expiredReserved = capability.status === 'expired' && capability.recoveryState === 'reserved';
-    if (!build.ok
-        || capability.taskId !== selector.taskId
-        || capability.hookDefinitionHash !== selector.expectedHookDefinitionHash
-        || capability.controller?.controlGeneration !== options.controllerBinding.controlGeneration
-        || capability.controller?.instanceDigest !== options.controllerBinding.instanceDigest
-        || capability.recoveryState === 'unreserved'
-        || capability.recoveryOperationId !== selector.operationId
-        || (!['attested', 'consumed'].includes(capability.status) && !expiredReserved)) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PROVENANCE_INVALID', 'durable capability provenance does not match the recovery request');
-    }
-    const phase = capability.recoveryPhases.find((entry) => entry.phase === selector.phase);
-    if (!phase) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PHASE_MISSING', 'durable task completion phase is missing');
-    }
-    const intents = findArtifactRecoveryIntentsByOperation(options.repoRoot, selector.operationId)
-        .filter((intent) => intent.taskId === selector.taskId
-        && intent.family === selector.family
-        && intent.artifact === selector.artifact);
-    if (intents.length !== 1) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not identify this task event');
-    }
-    const intent = intents[0];
-    if (!lifecycleRecoveryIntentMatches(intent, selector)
-        || intent.phase !== selector.phase
-        || intent.requestId !== selector.lifecycleRequestId
-        || intent.authorityDigest === null) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not match the recovery request');
-    }
-    if (!lifecycleRecoveryEventCommitted(selector, options.repoRoot)) {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_COMMIT_UNCONFIRMED', 'task completion is not durably present; compensation is not allowed');
-    }
-    if (capability.recoveryState === 'reserved') {
-        if (phase.state === 'issued') {
-            store.consumeRecoveryPhase(selector.authorityRef, selector.operationId, selector.phase, phase.requestId, expected, { allowExpiredReserved: true });
-        }
-        store.consumeReference(selector.authorityRef, selector.operationId, expected, { allowExpiredReserved: true });
-    }
-    else if (phase.state !== 'consumed') {
-        throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_STATE_INVALID', 'consumed capability has an unconsumed completion phase');
-    }
-    if (intent.state !== 'consumed') {
-        writeArtifactRecoveryIntent(options.repoRoot, {
-            ...intent,
-            state: 'consumed',
-            updatedAt: (options.now ?? Date.now)()
-        }, { expected: intent });
-    }
-    return queryLifecycleRecoveryOperation(selector.operationId, { repoRoot: options.repoRoot, capabilityStore: store });
-}
 function authorityRejected(request, code, message) {
     return { version: 1, requestId: request.requestId, operationId: request.operationId, phase: request.phase, status: 'rejected', attestation: null, error: { code, message } };
 }
@@ -406,6 +274,7 @@ export function createSandboxExecutorExecutionContext(params) {
         generation: params.generation,
         manifestPath: absolute('manifestPath', params.manifestPath),
         requestId: params.requestId,
+        handoffDirectory: absolute('handoffDirectory', params.handoffDirectory ?? path.join(params.worktreeRoot, '.agent-infra-handoff')),
         ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
         ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
             lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -433,6 +302,7 @@ export function assertTaskControlExecutionContext(context) {
     absolute('worktreeRoot', context.worktreeRoot);
     absolute('runtimeDir', context.runtimeDir);
     absolute('manifestPath', context.manifestPath);
+    absolute('handoffDirectory', context.handoffDirectory);
     if (path.resolve(context.runtimeDir) !== path.join(path.dirname(path.resolve(context.manifestPath)), 'runtime')) {
         invalidContext('runtimeDir is not bound to the manifest control root');
     }
@@ -463,10 +333,6 @@ function lifecycleTaskId(request, repoRoot) {
     }
 }
 async function applyLifecycleWithAuthority(context, request) {
-    const conflict = overrideDryRunConflict(request);
-    if (conflict) {
-        return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
-    }
     const execute = async () => {
         if (request.intent === 'recover-started') {
             const adapter = isAgentClientId(request.agent)
@@ -481,29 +347,7 @@ async function applyLifecycleWithAuthority(context, request) {
             }
             return adapter.recoverStarted(request, { repoRoot: context.repoRoot });
         }
-        const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
-        if (lifecycleResult.status !== 'failed' || !request.overrideTicket)
-            return lifecycleResult;
-        if (!request.overrideTarget || !request.overrideScope) {
-            return {
-                ...lifecycleResult,
-                error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
-            };
-        }
-        const override = await consumeHumanOverride({
-            taskRef: request.taskRef,
-            ticketId: request.overrideTicket,
-            failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
-            target: request.overrideTarget,
-            scope: request.overrideScope,
-            intent: request.intent,
-            ...('alertNumber' in request && request.alertNumber ? { alertNumber: request.alertNumber } : {}),
-            ...('issueNumber' in request && request.issueNumber ? { issueNumber: request.issueNumber } : {}),
-            ...('stagingDir' in request && request.stagingDir ? { stagingDir: request.stagingDir } : {})
-        }, { repoRoot: context.repoRoot });
-        if (override.status === 'failed')
-            return { ...lifecycleResult, humanOverride: override };
-        return { ...lifecycleResult, ...override, humanOverride: override, error: null };
+        return applyTaskLifecycle(request, { repoRoot: context.repoRoot });
     };
     const taskId = lifecycleTaskId(request, context.repoRoot);
     if (!taskId)
@@ -590,10 +434,13 @@ export function dispatchTaskControlOperation(context, operation) {
     }
     if (operation.family === 'task-finalization') {
         operationTaskId(context, operation.request.taskRef);
-        return applyTaskFinalization(operation.request, {
+        const finalize = context.source === 'sandbox-executor' ? commitPreparedTaskFinalization : applyTaskFinalization;
+        return finalize(operation.request, {
             repoRoot: context.repoRoot,
             ...(context.source === 'sandbox-executor' ? {
-                controlBinding: { generation: context.generation, requestId: context.requestId }
+                controlBinding: { generation: context.generation, requestId: context.requestId },
+                handoffDirectory: context.handoffDirectory,
+                manifestPath: context.manifestPath
             } : {}),
             preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
         });
@@ -628,7 +475,7 @@ function operationInvalid(message) {
 }
 const LIFECYCLE_FLAGS = new Set([
     '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-    '--auto', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+    '--auto', '--dry-run'
 ]);
 const FINALIZATION_FLAGS = new Set(['--agent']);
 const ORCHESTRATION_FLAGS = new Set([
@@ -699,9 +546,6 @@ export function parseTaskControlOperation(family, args) {
             ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
             ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
             ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
-            ...(value(values, '--override-ticket') ? { overrideTicket: value(values, '--override-ticket') } : {}),
-            ...(value(values, '--override-target') ? { overrideTarget: value(values, '--override-target') } : {}),
-            ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
             ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
             ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
             ...(values['--auto'] === true ? { auto: true } : {}),

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

@@ -6,7 +6,7 @@ import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SE
 import { resolveTaskContext } from './resolve-ref.js';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
+import { consumeHumanDecisionReworkIntents, parseReworkIntentDocument, reworkIntentMutation } from './rework-intent.js';
 const DECISION_ALIASES = ['人工裁决', 'Human Rulings', 'Human Decisions', 'Human Decision'];
 const ACTIVITY_ALIASES = ['活动日志', 'Activity Log'];
 function failed(code, message, taskId = null, ledgerId = null) {
@@ -57,8 +57,7 @@ function applyHumanDecision(request, options = {}) {
     const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
-    const stateOverride = allowsManualOverride(options.manualOverride, 'decision-intent', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -160,7 +159,18 @@ function applyHumanDecision(request, options = {}) {
         kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
         body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
     });
-    const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
+    try {
+        const parsedRework = parseReworkIntentDocument(content);
+        if (!parsedRework.ok)
+            return failed('DECISION_DOCUMENT_INVALID', parsedRework.message, resolved.taskId, row.id);
+        const consumed = consumeHumanDecisionReworkIntents(parsedRework.intents, row.id, metadata.timestamp);
+        if (consumed.changed)
+            mutations.push(reworkIntentMutation(content, consumed.intents));
+    }
+    catch (error) {
+        return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
+    }
+    const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
         ...options,
         taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
         metadataProvider: () => metadata