@fitlab-ai/agent-infra 0.11.4 → 0.11.6

package/dist/lib/sandbox/removal.js

@@ -17,6 +17,7 @@ import { acquireSandboxResourceLock } from './control/native-file-lock.js';
 import { toolConfigDirCandidates, toolProjectDirCandidates } from './tools.js';
 import { getProcessStartTime } from '../server/process-state.js';
 import { releaseStaleShortIdRegistry } from '../task/short-id.js';
+import { withRepositoryMutationLock } from '../task/task-execution-lock.js';
 import { fetchSandboxRows } from './commands/list-running.js';
 import { formatIntermediateCleanupReport, cleanupIntermediateUnderRemovalCoordinator, protectIntermediateCleanupReport, mergeIntermediateCleanupReports, scanIntermediateCleanup } from '../task/intermediate-cleanup.js';
 import { createSandboxControlBindingEvidence } from './task-cleanup.js';
@@ -670,7 +671,7 @@ async function runRmOneUnderRepositoryLock(config, tools, branch, options = {})
     return rmOneCore(config, tools, branch, { ...options, target });
 }
 async function rmOne(config, tools, branch, options = {}) {
-    await runRmOneUnderRepositoryLock(config, tools, branch, options);
+    await withRepositoryMutationLock(config.repoRoot, () => runRmOneUnderRepositoryLock(config, tools, branch, options));
 }
 async function removeUncheckedSandbox(config, target, options) {
     const confirm = options.prompt?.confirm ?? p.confirm;
@@ -703,8 +704,12 @@ async function removeUncheckedSandbox(config, target, options) {
             p.outro('Cancelled');
         return null;
     }
+    const worktreePermits = options.permits ?? await authorizeWorktrees(existingWorktrees, { allowDirtyDiscard: true, assumeYes: Boolean(options.assumeYes) }, { ...options.prompt, interactive: options.interactive });
     for (const container of matchedContainers)
         runSafeEngine(engine, 'docker', ['rm', '-f', container]);
+    if (!sandboxContainersRemoved(engine, matchedContainers)) {
+        throw new Error(`SANDBOX_REMOVAL_CONTAINER_STILL_PRESENT: ${matchedContainers.join(', ')}`);
+    }
     for (const root of controlRoots) {
         fs.rmSync(root, { recursive: true, force: true });
         removeEmptyManagedParent(path.join(config.controlBase, config.project), root);
@@ -720,14 +725,16 @@ async function removeUncheckedSandbox(config, target, options) {
     if (shouldRemoveShare)
         fs.rmSync(sharePath, { recursive: true, force: true });
     if (shouldRemoveWorktree) {
-        for (const worktree of existingWorktrees)
-            fs.rmSync(worktree, { recursive: true, force: true });
-        runSafe('git', ['-C', config.repoRoot, 'worktree', 'prune']);
+        for (const worktree of existingWorktrees) {
+            const permit = worktreePermits.get(path.resolve(worktree));
+            if (!permit)
+                throw new Error(`SANDBOX_WORKTREE_REMOVAL_PERMIT_MISSING: ${worktree}`);
+            removeWorktreeDir(config.repoRoot, config.worktreeBase, worktree, permit);
+        }
     }
-    if (shouldDeleteBranch)
+    if (shouldDeleteBranch) {
+        assertBranchRemovalIdentity(config, effectiveBranch, worktreePermits);
         runSafe('git', ['-C', config.repoRoot, 'branch', '-D', effectiveBranch]);
-    if (!sandboxContainersRemoved(engine, matchedContainers)) {
-        throw new Error(`SANDBOX_REMOVAL_CONTAINER_STILL_PRESENT: ${matchedContainers.join(', ')}`);
     }
     if (target.workspace.mode === 'task-bound') {
         releaseStaleShortIdRegistry(config.repoRoot, target.workspace.taskId);
@@ -741,7 +748,7 @@ async function rmOneCore(config, tools, branch, options = {}) {
     return removeUncheckedSandbox(config, target, options);
 }
 async function rmPurge(config, tools, prompt = {}) {
-    return rmPurgeCore(config, tools, prompt);
+    return withRepositoryMutationLock(config.repoRoot, () => rmPurgeCore(config, tools, prompt));
 }
 async function rmPurgeCore(config, tools, prompt = {}) {
     const engine = detectEngine(config);

package/dist/lib/sandbox/task-resolver.js

@@ -21,7 +21,9 @@ function stripQuotes(value) {
 }
 function readTaskContent(repoRoot, taskId) {
     for (const state of TASK_WORKSPACE_STATES) {
-        const taskPath = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
+        const taskPath = state === 'archive'
+            ? path.join(repoRoot, '.agents', 'workspace', state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
+            : path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
         if (fs.existsSync(taskPath)) {
             return { content: fs.readFileSync(taskPath, 'utf8'), state, taskMd: taskPath };
         }
@@ -29,7 +31,7 @@ function readTaskContent(repoRoot, taskId) {
     throw new Error(`Task not found: ${taskId}`);
 }
 function taskWorkspaceCandidates(repoRoot, taskId) {
-    return TASK_WORKSPACE_STATES.flatMap((state) => {
+    const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
         const taskMd = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
         if (!fs.existsSync(taskMd))
             return [];
@@ -41,6 +43,37 @@ function taskWorkspaceCandidates(repoRoot, taskId) {
                 taskMd
             }];
     });
+    const parts = findArchiveTaskParts(repoRoot, taskId);
+    if (parts.length === 0)
+        return hot;
+    const taskMd = path.join(repoRoot, '.agents', 'workspace', 'archive', ...parts, 'local', 'task.md');
+    if (!fs.existsSync(taskMd))
+        return hot;
+    const content = fs.readFileSync(taskMd, 'utf8');
+    return [...hot, {
+            taskId,
+            branch: resolveBranchFromTaskContent(content, taskId),
+            state: 'archive',
+            taskMd
+        }];
+}
+function findArchiveTaskParts(repoRoot, taskId) {
+    const archiveRoot = path.join(repoRoot, '.agents', 'workspace', 'archive');
+    if (!fs.existsSync(archiveRoot))
+        return [];
+    for (const year of fs.readdirSync(archiveRoot).sort().reverse()) {
+        if (!/^\d{4}$/.test(year))
+            continue;
+        for (const month of fs.readdirSync(path.join(archiveRoot, year)).sort().reverse()) {
+            if (!/^\d{2}$/.test(month))
+                continue;
+            for (const day of fs.readdirSync(path.join(archiveRoot, year, month)).sort().reverse()) {
+                if (/^\d{2}$/.test(day) && fs.existsSync(path.join(archiveRoot, year, month, day, taskId, 'local', 'task.md')))
+                    return [year, month, day, taskId];
+            }
+        }
+    }
+    return [];
 }
 function resolveBranchFromTaskContent(content, taskId) {
     const frontmatterBranch = content.match(/^branch:\s*(.+)$/m);
@@ -81,6 +114,33 @@ export function resolveTaskWorkspace(taskId, repoRoot) {
 }
 export function listTaskWorkspaces(repoRoot, state) {
     const stateRoot = path.join(repoRoot, '.agents', 'workspace', state);
+    if (state === 'archive') {
+        if (!fs.existsSync(stateRoot))
+            return [];
+        const rows = [];
+        for (const year of fs.readdirSync(stateRoot).sort()) {
+            if (!/^\d{4}$/.test(year))
+                continue;
+            for (const month of fs.readdirSync(path.join(stateRoot, year)).sort()) {
+                if (!/^\d{2}$/.test(month))
+                    continue;
+                for (const day of fs.readdirSync(path.join(stateRoot, year, month)).sort()) {
+                    if (!/^\d{2}$/.test(day))
+                        continue;
+                    for (const taskId of fs.readdirSync(path.join(stateRoot, year, month, day)).sort()) {
+                        if (!TASK_ID_RE.test(taskId))
+                            continue;
+                        const taskMd = path.join(stateRoot, year, month, day, taskId, 'local', 'task.md');
+                        if (!fs.existsSync(taskMd))
+                            continue;
+                        const content = fs.readFileSync(taskMd, 'utf8');
+                        rows.push({ taskId, branch: resolveBranchFromTaskContent(content, taskId), state, taskMd });
+                    }
+                }
+            }
+        }
+        return rows;
+    }
     if (!fs.existsSync(stateRoot))
         return [];
     return fs.readdirSync(stateRoot, { withFileTypes: true })

package/dist/lib/task/activity-intent.js

@@ -6,7 +6,6 @@ import { assertWritableInventory, buildArtifactLinkSection, inspectTaskArtifacts
 import { parseArtifactName } from './artifact-name.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
 const HEAD_RE = /^[0-9a-f]{40}$/;
 const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS = new Set(['approved', 'changes-requested', 'commented']);
@@ -294,7 +293,7 @@ export function applyPrReviewActivityIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'activity-intent', 'TASK_STATE_MISMATCH')) {
+    if (resolved.state !== 'active') {
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     }
     if (options.lockAlreadyHeld)

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

@@ -166,10 +166,44 @@ function inspectArtifactPatterns(content, schema) {
         diagnostics
     };
 }
-function inspectArtifactContract(content, schema) {
+function inspectArtifactStateCheck(content, schema, scopeToStateCheckSection) {
+    const stateCheck = schema.sections.find((section) => section.id === 'state-check');
+    if (!stateCheck || schema.stateCheckPatterns.length === 0) {
+        return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };
+    }
+    if (!scopeToStateCheckSection) {
+        const diagnostics = schema.stateCheckPatterns
+            .filter((pattern) => !new RegExp(pattern, 'm').test(content))
+            .map((pattern) => diagnostic('ARTIFACT_STATE_CHECK_PATTERN_MISSING', `artifact is missing required state-check command '${pattern}'`, stateCheck.id, null));
+        return {
+            ok: diagnostics.length === 0,
+            family: schema.family,
+            semanticDigest: canonicalSemanticDigest(content),
+            diagnostics
+        };
+    }
+    const scanned = scanVisibleMarkdown(content);
+    const headings = scanned.headings.filter((heading) => (heading.level === 2 && sectionHeadings(schema, stateCheck).includes(heading.text)));
+    if (headings.length !== 1) {
+        return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };
+    }
+    const bodyBounds = sectionBodyBounds(content, headings[0], scanned);
+    const body = content.slice(bodyBounds.start, bodyBounds.end);
+    const diagnostics = schema.stateCheckPatterns
+        .filter((pattern) => !new RegExp(pattern, 'm').test(body))
+        .map((pattern) => diagnostic('ARTIFACT_STATE_CHECK_PATTERN_MISSING', `state-check section is missing required command '${pattern}'`, stateCheck.id, lineNumber(content, headings[0].start)));
+    return {
+        ok: diagnostics.length === 0,
+        family: schema.family,
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
+    };
+}
+function inspectArtifactContract(content, schema, options = {}) {
     const structure = inspectArtifactStructure(content, schema);
+    const stateCheck = inspectArtifactStateCheck(content, schema, options.scopeStateCheckSection === true);
     const patterns = inspectArtifactPatterns(content, schema);
-    const diagnostics = [...structure.diagnostics, ...patterns.diagnostics];
+    const diagnostics = [...structure.diagnostics, ...stateCheck.diagnostics, ...patterns.diagnostics];
     return {
         ok: diagnostics.length === 0,
         family: schema.family,

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

@@ -81,21 +81,21 @@ function buildSections(family) {
         marker: `artifact-section:${family}:${id}`
     }));
 }
+const TASK_SNAPSHOT_PATTERN = 'agent-infra-internal[ \\t]+task-snapshot\\b';
 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: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+    { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+    { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+    { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+    { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], 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*$'
-        ] }
+        ], stateCheckPatterns: [TASK_SNAPSHOT_PATTERN] }
 ];
 function getArtifactSchema(family) {
     return ARTIFACT_SCHEMAS.find((schema) => schema.family === family) ?? null;

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, 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)
@@ -594,7 +438,9 @@ export function dispatchTaskControlOperation(context, operation) {
         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)
         });
@@ -629,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([
@@ -700,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,6 @@ 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'];
@@ -58,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;
@@ -172,7 +170,7 @@ function applyHumanDecision(request, options = {}) {
     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: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
+    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

package/dist/lib/task/events.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { resolveBranchWorktree } from '../git/branch-worktree.js';
 import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
 import { buildArtifactLinkSection, inspectArtifactDirectory, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
 import { artifactName, parseArtifactName } from './artifact-name.js';
@@ -16,7 +17,6 @@ import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { commitOrchestrationStageCompletion } from './orchestration.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
 import { validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.js';
 import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
@@ -41,24 +41,7 @@ const eventCatalog = [
 function branchWorktree(repoRoot, branch) {
     if (!branch)
         return repoRoot;
-    try {
-        const records = execFileSync('git', ['worktree', 'list', '--porcelain'], {
-            cwd: repoRoot,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'pipe']
-        }).trim().split(/\r?\n\r?\n/);
-        const expectedRef = `refs/heads/${branch}`;
-        for (const record of records) {
-            const worktree = /^worktree (.+)$/m.exec(record)?.[1];
-            const branchRef = /^branch (.+)$/m.exec(record)?.[1];
-            if (worktree && branchRef === expectedRef)
-                return worktree;
-        }
-    }
-    catch {
-        // A missing worktree must not anchor a review to an unrelated repository.
-    }
-    return null;
+    return resolveBranchWorktree(repoRoot, branch);
 }
 function approvedCleanReviewedCommit(reviewContent, verdict, repoRoot, branch) {
     if (verdict !== 'approved')
@@ -84,7 +67,7 @@ function approvedCleanReviewedCommit(reviewContent, verdict, repoRoot, branch) {
         return null;
     }
 }
-const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
+const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
 const SCHEMAS = {
     'analyze.started': { optional: ['round'] },
     'analyze.awaiting-input': { required: ['question'] },
@@ -722,8 +705,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(request, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
-    const stateOverride = allowsManualOverride(options.manualOverride, 'task-event', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     let content;
     try {
@@ -842,7 +824,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         }
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.started, frontmatter, artifactContext);
     }
-    if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0 && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING'))
+    if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0)
         return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires a started event or an earlier completed attempt' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     if (eventIdentity.phase === 'completed') {
         const validated = validateCompletedArtifact(resolved.taskDir, FAMILY[eventIdentity.family].artifact, normalized.artifact, normalized.round);
@@ -912,12 +894,9 @@ function applyTaskEventUnlocked(request, options = {}) {
         if (!facts.ok)
             return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${facts.code}: ${facts.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
-        const capabilityOverride = capability.reasonCode === 'TASK_NOT_ACTIVE'
-            ? stateOverride
-            : allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID');
         const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
             || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
-        if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure) && !capabilityOverride) {
+        if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)) {
             const code = capability.reasonCode === 'INVALIDATION_INCOMPLETE' ? 'TASK_INVALIDATION_BLOCKED' : 'EVENT_TRANSITION_INVALID';
             return failed(normalized, { code, message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
@@ -1073,7 +1052,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
     const sourceCompletion = eventIdentity.phase === 'completed'
         && ['analyze', 'plan', 'code'].includes(eventIdentity.family);
-    const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
+    const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
     if (!normalized.dryRun && orchestrationCompletion) {