@fitlab-ai/agent-infra 0.11.9 → 0.11.11

package/dist/lib/task/current-contract.js

@@ -1,7 +1,6 @@
 import { isValidAgentInfraVersion } from '../version.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.js';
-import { parseInvalidationDocument } from './invalidation.js';
 function validateCurrentTaskContract(content) {
     let metadata;
     try {
@@ -30,10 +29,7 @@ function validateCurrentTaskContract(content) {
     const invalid = validateLedgerRows(ledger.rows);
     if (invalid)
         return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalid.code}: ${invalid.message}` };
-    const invalidation = parseInvalidationDocument(content);
-    if (!invalidation.ok)
-        return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalidation.code}: ${invalidation.message}` };
-    return { ok: true, metadata, ledger, invalidation: invalidation.document };
+    return { ok: true, metadata, ledger };
 }
 export { validateCurrentTaskContract };
 //# sourceMappingURL=current-contract.js.map

package/dist/lib/task/events.js

@@ -19,10 +19,8 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { validateLocalArtifact } from './local-artifact-finalization.js';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.js';
-import { createInvalidationOperation, invalidationMutation, parseInvalidationDocument, targetIdFor, upsertInvalidation } from './invalidation.js';
-import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { consumeReworkIntents, parseReworkIntentDocument, reworkIntentMutation, supersedeReworkIntents } from './rework-intent.js';
-import { ARTIFACT_FAMILIES, parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
+import { parseTaskQualification } from './qualification-audit.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract } from './artifact-operations.js';
 import { inspectReviewIdentity } from './review-identity.js';
@@ -115,7 +113,7 @@ function validateTaskEventRequest(request) {
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'initiator is invalid' };
     if (request.requestId !== undefined && (!request.requestId.trim() || /[\r\n]/.test(request.requestId)))
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'requestId must be a non-empty single line' };
-    if (request.reasonCode && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'retry', 'validation-rerun'].includes(request.reasonCode))
+    if (request.reasonCode && !['user-request', 'new-requirement', 'upstream-fact-doubt', 'review-finding', 'manual-review-supplement', 'retry', 'validation-rerun'].includes(request.reasonCode))
         return { code: 'EVENT_PAYLOAD_INVALID', message: 'reasonCode is invalid' };
     for (const [name, value] of [['sourceFinding', request.sourceFinding], ['sourceArtifact', request.sourceArtifact], ['sourceSha256', request.sourceSha256]]) {
         if (value !== undefined && (!value.trim() || /[\r\n]/.test(value)))
@@ -370,235 +368,6 @@ function eventTrigger(request, family) {
         explicitRequest: request.requestId !== undefined || request.reasonCode !== undefined || request.initiator !== undefined || request.orchestrated === true
     };
 }
-function receiptGraphHasCycle(receipts) {
-    const edges = new Map();
-    for (const receipt of receipts) {
-        const outputs = edges.get(receipt.input) ?? [];
-        outputs.push(receipt.output);
-        edges.set(receipt.input, outputs);
-    }
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (node) => {
-        if (visiting.has(node))
-            return true;
-        if (visited.has(node))
-            return false;
-        visiting.add(node);
-        for (const output of edges.get(node) ?? [])
-            if (visit(output))
-                return true;
-        visiting.delete(node);
-        visited.add(node);
-        return false;
-    };
-    return [...edges.keys()].some(visit);
-}
-function qualificationInvalidationSeeds(content, taskDir, inventory, baselineDigest) {
-    const task = parseTaskQualification(content);
-    if (!task.ok)
-        return { changed: true, safe: false, seeds: [] };
-    if (baselineDigest !== undefined) {
-        if (!/^[a-f0-9]{64}$/u.test(baselineDigest))
-            return { changed: true, safe: false, seeds: [] };
-        if (baselineDigest === task.qualification.taskInputDigest)
-            return { changed: false, safe: true, seeds: [] };
-    }
-    const audits = [];
-    let observedQualification = false;
-    for (const artifact of inventory) {
-        let artifactContent;
-        try {
-            artifactContent = fs.readFileSync(path.join(taskDir, artifact.name), 'utf8');
-        }
-        catch {
-            return { changed: true, safe: false, seeds: [] };
-        }
-        const parsed = parseQualificationAudit(artifactContent);
-        if (!parsed.ok)
-            return { changed: true, safe: false, seeds: [] };
-        if (!parsed.audit.present)
-            continue;
-        observedQualification = true;
-        const snapshot = parsed.audit.snapshot;
-        if (!snapshot)
-            return { changed: true, safe: false, seeds: [] };
-        audits.push({
-            name: artifact.name,
-            snapshotTaskDigest: snapshot.taskInputDigest,
-            snapshotNonConstraintDigest: snapshot.nonConstraintInputDigest,
-            dependencies: parsed.audit.constraintDependencies,
-            candidates: parsed.audit.candidateQualifications
-        });
-    }
-    if (!task.qualification.present)
-        return { changed: false, safe: true, seeds: [] };
-    const allAuditsPresent = observedQualification && audits.length === inventory.length;
-    if (!allAuditsPresent)
-        return { changed: true, safe: false, seeds: [] };
-    if (baselineDigest === undefined && audits.every((audit) => audit.snapshotTaskDigest === task.qualification.taskInputDigest)) {
-        return { changed: false, safe: true, seeds: [] };
-    }
-    const candidateMap = new Map(task.qualification.candidates.map((candidate) => [candidate.candidateId, candidate]));
-    const currentConstraints = new Map(task.qualification.constraints.map((constraint) => [constraint.constraintId, constraint.digest]));
-    const snapshotsMatch = audits.every((audit) => audit.snapshotNonConstraintDigest === task.qualification.nonConstraintInputDigest);
-    const candidatesMatch = audits.every((audit) => audit.candidates.length === candidateMap.size
-        && audit.candidates.every((row) => {
-            const current = candidateMap.get(row.candidateId);
-            return Boolean(current && row.status === current.status && row.impact === current.impact
-                && row.evidence === current.evidence && row.constraintIds.join(',') === current.constraintIds.join(','));
-        }));
-    const changedConstraints = new Set();
-    let referencesValid = true;
-    for (const audit of audits) {
-        for (const dependency of audit.dependencies) {
-            const currentDigest = currentConstraints.get(dependency.constraintId);
-            if (!currentDigest)
-                referencesValid = false;
-            else if (currentDigest !== dependency.constraintDigest)
-                changedConstraints.add(dependency.constraintId);
-        }
-    }
-    const safe = allAuditsPresent && snapshotsMatch && candidatesMatch && referencesValid && changedConstraints.size > 0;
-    if (!safe)
-        return { changed: true, safe: false, seeds: [] };
-    const seeds = new Set();
-    for (const audit of audits) {
-        if (audit.dependencies.some((dependency) => changedConstraints.has(dependency.constraintId)))
-            seeds.add(audit.name);
-    }
-    return { changed: true, safe: true, seeds: [...seeds] };
-}
-function invalidationMutationForCompletion(content, taskDir, family, artifact, timestamp, frontmatter) {
-    if (!['analyze', 'plan', 'code'].includes(family))
-        return { mutation: null };
-    const parsed = parseInvalidationDocument(content);
-    if (!parsed.ok)
-        return { error: parsed.message };
-    const downstream = {
-        analyze: ['review-analysis', 'plan', 'review-plan', 'code', 'review-code'],
-        plan: ['review-plan', 'code', 'review-code'],
-        code: ['review-code']
-    };
-    const qualificationFallback = ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'];
-    const sourceFamily = family;
-    const sourceArtifactFamily = sourceFamily === 'analyze' ? 'analysis' : sourceFamily;
-    let receipts = [];
-    try {
-        receipts = parseArtifactReceipts(content).rows;
-    }
-    catch (error) {
-        return { error: error instanceof Error ? error.message : String(error) };
-    }
-    const inventory = fs.readdirSync(taskDir).flatMap((name) => {
-        const identity = parseArtifactName(name);
-        if (!identity || !ARTIFACT_FAMILIES.includes(identity.family))
-            return [];
-        try {
-            const stat = fs.lstatSync(path.join(taskDir, name));
-            if (!stat.isFile() || stat.isSymbolicLink())
-                return [];
-            return [{ family: identity.family, name, round: identity.round, sha256: sha256File(path.join(taskDir, name)) }];
-        }
-        catch (error) {
-            throw new Error(`cannot inspect invalidation artifact '${name}': ${error instanceof Error ? error.message : String(error)}`);
-        }
-    });
-    const nodeMap = new Map(inventory.map((node) => [`${node.family}/${node.name}`, node]));
-    let graphUsable = receipts.length > 0;
-    for (const receipt of receipts) {
-        const output = parseArtifactName(receipt.output);
-        const input = nodeMap.get(`${parseArtifactName(receipt.input)?.family}/${receipt.input}`);
-        if (!output || !nodeMap.has(`${output.family}/${receipt.output}`) || !input || input.sha256 !== receipt.inputSha256) {
-            graphUsable = false;
-            break;
-        }
-    }
-    if (graphUsable && receiptGraphHasCycle(receipts))
-        graphUsable = false;
-    if (inventory.some((node) => node.family !== 'analysis' && node.name !== artifact.name
-        && !receipts.some((receipt) => receipt.output === node.name)))
-        graphUsable = false;
-    const selected = new Set();
-    if (graphUsable) {
-        const currentIdentity = parseArtifactName(artifact.name);
-        const previousName = currentIdentity && currentIdentity.round > 1 ? artifactName(sourceArtifactFamily, currentIdentity.round - 1) : null;
-        const previous = previousName ? inventory.find((node) => node.family === sourceArtifactFamily && node.name === previousName) : null;
-        const previousFact = previousName ? parseCompletionFacts(frontmatter.completion_facts).find((fact) => fact.output === previousName && fact.event === `${sourceFamily === 'analyze' ? 'analysis' : sourceFamily}.completed`) : null;
-        if (!previous || !previousFact || previousFact.outputSha256 !== previous.sha256)
-            graphUsable = false;
-        if (graphUsable && previous) {
-            selected.add(`${previous.family}/${previous.name}`);
-            let changed = true;
-            while (changed) {
-                changed = false;
-                for (const receipt of receipts) {
-                    const consumer = `${parseArtifactName(receipt.output).family}/${receipt.output}`;
-                    if (selected.has(`${parseArtifactName(receipt.input).family}/${receipt.input}`) && !selected.has(consumer)) {
-                        selected.add(consumer);
-                        changed = true;
-                    }
-                }
-            }
-            selected.delete(`${previous.family}/${previous.name}`);
-        }
-    }
-    const qualification = qualificationInvalidationSeeds(content, taskDir, inventory, typeof frontmatter.qualification_input_digest === 'string' ? frontmatter.qualification_input_digest : undefined);
-    let qualificationChange = qualification.changed;
-    if (qualificationChange && (!graphUsable || !qualification.safe))
-        graphUsable = false;
-    if (qualificationChange && graphUsable) {
-        for (const seed of qualification.seeds)
-            selected.add(`${parseArtifactName(seed)?.family}/${seed}`);
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const receipt of receipts) {
-                const consumer = `${parseArtifactName(receipt.output).family}/${receipt.output}`;
-                if (selected.has(`${parseArtifactName(receipt.input).family}/${receipt.input}`) && !selected.has(consumer)) {
-                    selected.add(consumer);
-                    changed = true;
-                }
-            }
-        }
-    }
-    const reasonCode = qualificationChange ? 'qualification-changed' : 'upstream-replaced';
-    const fallbackFamilies = qualificationChange ? qualificationFallback : downstream[sourceFamily];
-    const targetNodes = (graphUsable
-        ? inventory.filter((node) => selected.has(`${node.family}/${node.name}`))
-        : inventory.filter((node) => fallbackFamilies.includes(node.family)))
-        .filter((node) => !(node.family === FAMILY[family].artifact && node.name === artifact.name));
-    const targets = targetNodes.flatMap((node) => {
-        const shapes = [
-            { targetKind: 'artifact', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 }
-        ];
-        for (const receipt of receipts.filter((candidate) => candidate.output === node.name)) {
-            shapes.push({ targetKind: 'receipt', targetFamily: node.family, targetArtifact: node.name, targetInput: receipt.input, targetRound: node.round, targetSha256: receipt.inputSha256 });
-        }
-        if (node.family.startsWith('review-'))
-            shapes.push({ targetKind: 'approval', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 });
-        if (node.family === 'review-code')
-            shapes.push({ targetKind: 'reviewed-snapshot', targetFamily: node.family, targetArtifact: node.name, targetRound: node.round, targetSha256: node.sha256 });
-        return shapes.map((targetShape) => ({ ...targetShape, targetId: targetIdFor('pending', targetShape), operationId: 'pending', status: 'pending', reasonCode, updatedAt: timestamp }));
-    });
-    if (targets.length === 0)
-        return { mutation: null };
-    const source = {
-        sourceFamily: lifecycleAction(family), sourceArtifact: artifact.name,
-        sourceRound: parseArtifactName(artifact.name)?.round ?? 1, sourceSha256: sha256File(artifact.path),
-        createdAt: timestamp, updatedAt: timestamp
-    };
-    const operation = createInvalidationOperation(source);
-    const normalizedTargets = targets.map((target) => ({
-        ...target, operationId: operation.operationId,
-        targetId: targetIdFor(operation.operationId, target)
-    }));
-    const operationWithTotal = createInvalidationOperation(source, normalizedTargets);
-    const next = upsertInvalidation(parsed.document, operationWithTotal, normalizedTargets);
-    if (!next.ok)
-        return { error: next.message };
-    return { mutation: next.changed ? invalidationMutation(content, next.document) : null };
-}
 function reworkIntentMutationForCompletion(content, taskDir, family, artifact, timestamp) {
     const parsed = parseReworkIntentDocument(content);
     if (!parsed.ok)
@@ -606,23 +375,15 @@ function reworkIntentMutationForCompletion(content, taskDir, family, artifact, t
     const hash = sha256File(artifact.path);
     let next = parsed.intents;
     if (family === 'analyze' || family === 'plan' || family === 'code') {
-        const hashes = Object.fromEntries(fs.readdirSync(taskDir).flatMap((name) => {
-            if (!/^review-(?:analysis|plan|code)(?:-r\d+)?\.md$/.test(name))
-                return [];
-            try {
-                return [[name, sha256File(path.join(taskDir, name))]];
-            }
-            catch {
-                return [];
-            }
+        const hashes = Object.fromEntries(['review-analysis', 'review-plan', 'review-code'].flatMap((reviewFamily) => {
+            const inventory = inspectArtifactDirectory(taskDir, reviewFamily);
+            return inventory.status === 'ready' ? inventory.completed.map((review) => [review.name, sha256File(review.path)]) : [];
         }));
         const action = family === 'analyze' ? 'analysis' : family;
         let target = action;
         if (family === 'analyze') {
-            const previousAnalysis = fs.readdirSync(taskDir)
-                .map((name) => parseArtifactName(name))
-                .filter((identity) => identity?.family === 'analysis' && identity.name !== artifact.name)
-                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            const previousAnalysis = inspectArtifactDirectory(taskDir, 'analysis').completed
+                .filter((identity) => identity.name !== artifact.name).at(-1);
             const pathState = previousAnalysis
                 ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, previousAnalysis.name), 'utf8'))
                 : undefined;
@@ -764,23 +525,6 @@ function applyTaskEventUnlocked(request, options = {}) {
         return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
     const initialParts = eventParts(request.event);
-    if (initialParts.phase === 'started' && !request.dryRun) {
-        const reconciled = reconcileTaskInvalidation(request.taskRef, { repoRoot: resolved.repoRoot });
-        if (reconciled.status === 'failed') {
-            return failed(request, {
-                code: 'EVENT_TRANSITION_INVALID',
-                message: `INVALIDATION_RECONCILE_FAILED: ${reconciled.error?.code ?? 'UNKNOWN'}: ${reconciled.error?.message ?? ''}`
-            }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-        }
-        if (reconciled.changed) {
-            try {
-                content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-            }
-            catch (error) {
-                return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
-            }
-        }
-    }
     let frontmatter;
     try {
         frontmatter = parseTypedTaskFrontmatter(content);
@@ -946,8 +690,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
             || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
         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 });
+            return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
     }
     const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
@@ -985,7 +728,6 @@ function applyTaskEventUnlocked(request, options = {}) {
     }
     let completionReceipts = [];
     let currentFact = null;
-    let completionInvalidation = null;
     let completionRework = null;
     if (eventIdentity.phase === 'completed' && completedArtifact) {
         const receipt = buildCompletionReceipt(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter, normalized);
@@ -1006,10 +748,6 @@ function applyTaskEventUnlocked(request, options = {}) {
             return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, completionReceipts[0]?.completedAt ?? metadata.timestamp, frontmatter, artifactContext);
         }
         try {
-            const invalidation = invalidationMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
-            if ('error' in invalidation)
-                return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: invalidation.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-            completionInvalidation = invalidation.mutation;
             const rework = reworkIntentMutationForCompletion(content, resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp);
             if ('error' in rework)
                 return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: rework.error }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -1104,8 +842,6 @@ function applyTaskEventUnlocked(request, options = {}) {
             return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
         }
     }
-    if (completionInvalidation)
-        mutations.push(completionInvalidation);
     if (completionRework)
         mutations.push(completionRework);
     if (eventIdentity.phase === 'completed' && normalized.implementationInput) {
@@ -1123,9 +859,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: '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, 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) {

package/dist/lib/task/execution-inputs.js

@@ -0,0 +1,14 @@
+import { pathIncludes } from './lifecycle-path.js';
+function expectedExecutionInputFamilies(stage, pathState) {
+    if (pathState.status !== 'valid')
+        return [];
+    const input = stage === 'plan' ? 'analysis' : pathIncludes(pathState, 'plan') ? 'plan' : 'analysis';
+    const review = input === 'plan' ? 'review-plan' : 'review-analysis';
+    return [input, ...(pathIncludes(pathState, review) ? [review] : [])];
+}
+function executionInputsMatchLatest(stage, pathState, latest, captured) {
+    const expected = expectedExecutionInputFamilies(stage, pathState);
+    return expected.every((family) => Boolean(latest[family] && captured.includes(latest[family])));
+}
+export { expectedExecutionInputFamilies, executionInputsMatchLatest };
+//# sourceMappingURL=execution-inputs.js.map

package/dist/lib/task/finalization-envelope.js

@@ -0,0 +1,4 @@
+export function serializeTaskFinalizationEnvelope(envelope) {
+    return `${JSON.stringify({ version: 2, ...envelope })}\n`;
+}
+//# sourceMappingURL=finalization-envelope.js.map

package/dist/lib/task/finalization.js

@@ -10,22 +10,45 @@ import { resourceIdentityEquals } from '../platform/resource-identity.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { recoverPlatformOperations } from './platform-operation-recovery.js';
 import { applyTaskLifecycle, inspectTaskLifecycleProgress, previewTaskCompletion } from './lifecycle.js';
-import { resolveTaskRef } from './resolve-ref.js';
+import { enumerateAllTaskDirs, resolveTaskRef } from './resolve-ref.js';
 import { inspectShortIdRegistry } from './short-id.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { verifyTaskEvent } from './verification.js';
 import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-import { readTaskFinalizationHandoff } from './finalization-handoff.js';
 import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { validateSandboxControlIdentity } from '../sandbox/control/identity-sentinel.js';
 const RECEIPT_VERSION = 4;
 const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'];
-function finalizationRoot(repoRoot) {
-    return path.join(repoRoot, '.agents', 'workspace', '.task-finalization');
+export function resolveTaskFinalizationDirectory(repoRoot, taskId) {
+    const tasks = enumerateAllTaskDirs(repoRoot).filter((task) => task.taskId === taskId);
+    if (tasks.length === 0)
+        return null;
+    if (tasks.length !== 1)
+        throw new Error(`FINALIZATION_TASK_IDENTITY_AMBIGUOUS: ${taskId}`);
+    const task = tasks[0];
+    let canonicalDir;
+    try {
+        canonicalDir = fs.realpathSync.native(task.taskDir);
+    }
+    catch (error) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_UNAVAILABLE: ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let frontmatter;
+    try {
+        frontmatter = parseTaskFrontmatter(fs.readFileSync(path.join(canonicalDir, 'task.md'), 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_INVALID: ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (task.taskId !== taskId || frontmatter.id !== taskId) {
+        throw new Error(`FINALIZATION_TASK_IDENTITY_INVALID: task directory and task.md must identify ${taskId}`);
+    }
+    return canonicalDir;
 }
 function receiptPath(repoRoot, taskId) {
-    return path.join(finalizationRoot(repoRoot), `${taskId}.json`);
+    const taskDir = resolveTaskFinalizationDirectory(repoRoot, taskId);
+    return taskDir ? path.join(taskDir, '.task-finalization.json') : null;
 }
 function now() {
     return new Date().toISOString();
@@ -89,7 +112,7 @@ function validWarning(value) {
         && (warning.status === 'open' || warning.status === 'resolved')
         && (warning.resolvedAt === null || typeof warning.resolvedAt === 'string');
 }
-function validateReceipt(value, taskId) {
+export function validateTaskFinalizationReceipt(value, taskId) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('receipt must be an object');
     const receipt = value;
@@ -128,18 +151,18 @@ function validateReceipt(value, taskId) {
 }
 function readReceipt(repoRoot, taskId) {
     const file = receiptPath(repoRoot, taskId);
-    if (!fs.existsSync(file))
+    if (!file || !fs.existsSync(file))
         return null;
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return validateReceipt(value, taskId);
+    return validateTaskFinalizationReceipt(value, taskId);
 }
 function readTaskFinalizationReceipt(repoRoot, taskId) {
     return readReceipt(path.resolve(repoRoot), taskId);
 }
 function writeReceipt(repoRoot, receipt) {
-    const directory = finalizationRoot(repoRoot);
-    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
     const target = receiptPath(repoRoot, receipt.taskId);
+    if (!target)
+        throw new Error(`TASK_FINALIZATION_TASK_NOT_FOUND: ${receipt.taskId}`);
     const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
     try {
         fs.writeFileSync(temporary, `${JSON.stringify(receipt)}\n`, { mode: 0o600, flag: 'wx' });
@@ -670,7 +693,7 @@ async function prepareUnderLock(request, taskId, options) {
     let receipt;
     try {
         const file = receiptPath(repoRoot, taskId);
-        const existed = fs.existsSync(file);
+        const existed = file !== null && fs.existsSync(file);
         receipt = readReceipt(repoRoot, taskId) ?? emptyReceipt(taskId, options.controlBinding);
         if (!existed)
             writeReceipt(repoRoot, receipt);
@@ -678,16 +701,6 @@ async function prepareUnderLock(request, taskId, options) {
     catch (error) {
         return failed(taskId, errorOf(error, 'TASK_FINALIZATION_RECEIPT_INVALID'));
     }
-    if (options.controlBinding && (receipt.controlBinding?.generation !== options.controlBinding.generation
-        || receipt.controlBinding.requestId !== options.controlBinding.requestId)) {
-        const state = resolveTaskRef(taskId, { repoRoot });
-        if (!(receipt.lifecycle === 'done' && state.ok && state.state === 'completed')) {
-            return failed(taskId, {
-                code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                message: 'canonical receipt is not bound to the current sandbox request', retryable: false
-            });
-        }
-    }
     const preflightState = resolveTaskRef(taskId, { repoRoot });
     if (options.preflight && preflightState.ok && preflightState.state === 'active') {
         try {
@@ -710,7 +723,7 @@ async function prepareUnderLock(request, taskId, options) {
     if (preflightState.ok && preflightState.state === 'active') {
         const recovery = await recoverPlatformOperations(taskId, 'all', { agent: request.agent, cwd: repoRoot });
         if (recovery.status !== 'applied' && recovery.status !== 'no-op') {
-            return failed(taskId, recovery.error ?? {
+            return failed(taskId, recovery.error ? { ...recovery.error, retryable: true } : {
                 code: 'PLATFORM_OPERATION_RECOVERY_PENDING',
                 message: 'Pending platform operations remain unresolved',
                 retryable: true
@@ -720,12 +733,10 @@ async function prepareUnderLock(request, taskId, options) {
         const taskFrontmatter = parseTaskFrontmatter(taskContent);
         const issueIdentity = taskIssueIdentity(taskFrontmatter);
         if (issueIdentity) {
-            const base = typeof taskFrontmatter.delivery_base_ref === 'string' ? taskFrontmatter.delivery_base_ref.trim() : '';
             let synced;
             try {
                 synced = await issueSync(taskId, {
-                    agent: request.agent, cwd: repoRoot, requirements: true, issueType: true, fields: true,
-                    ...(base ? { inLabels: 'from-diff', base } : {}), dependency: 'required'
+                    agent: request.agent, cwd: repoRoot, requirements: true, issueType: true, fields: true, dependency: 'required'
                 });
             }
             catch (error) {
@@ -733,7 +744,7 @@ async function prepareUnderLock(request, taskId, options) {
                 return failed(taskId, detail);
             }
             const issueOperations = synced.operations;
-            const badOperation = issueOperations?.find((operation) => ['requirements', 'issue-type', 'fields', ...(base ? ['labels:in'] : [])].includes(operation.name)
+            const badOperation = issueOperations?.find((operation) => ['requirements', 'issue-type', 'fields'].includes(operation.name)
                 && operation.status !== 'applied' && operation.status !== 'no-op'
                 && !(operation.name === 'requirements' && operation.status === 'skipped' && operation.reasonCode === 'NO_REQUIREMENTS_ANCHOR'));
             if ((synced.status !== 'applied' && synced.status !== 'no-op') || synced.error || badOperation) {
@@ -759,7 +770,7 @@ async function prepareUnderLock(request, taskId, options) {
                     retryable: true
                 });
             }
-            for (const name of ['requirements', 'issue-type', 'fields', ...(base ? ['labels:in'] : [])]) {
+            for (const name of ['requirements', 'issue-type', 'fields']) {
                 const operation = issueOperations?.find((candidate) => candidate.name === name);
                 if (!operation)
                     return failed(taskId, {
@@ -782,14 +793,6 @@ async function prepareUnderLock(request, taskId, options) {
                             code: 'FINALIZATION_ISSUE_TYPE_UNCONFIRMED', message: 'Issue Type did not match the verified target', retryable: true
                         });
                 }
-                else if (name === 'labels:in') {
-                    const expected = Array.isArray(operation.value) ? operation.value : before?.labels;
-                    if (!expected || expected.filter((label) => label.startsWith('in:')).sort().join('\0')
-                        !== remote.labels.filter((label) => label.startsWith('in:')).sort().join('\0'))
-                        return failed(taskId, {
-                            code: 'FINALIZATION_IN_LABELS_UNCONFIRMED', message: 'Issue in-labels did not match the verified target', retryable: true
-                        });
-                }
                 else {
                     const expected = operation.value && typeof operation.value === 'object'
                         ? operation.value
@@ -989,70 +992,24 @@ async function commitPreparedTaskFinalization(request, options) {
                 }
             }
             let receipt = readReceipt(repoRoot, resolved.taskId);
-            if (!receipt && options.controlBinding && options.handoffDirectory && request.handoffSha256) {
-                try {
-                    const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
-                    receipt = validateReceipt(handoff.receipt, resolved.taskId);
-                    if (receipt.lifecycle !== 'pending')
-                        throw new Error('handoff lifecycle must be pending');
-                    if (inspectTaskLifecycleProgress(repoRoot, resolved.taskId, request.agent) === 'unknown') {
-                        throw new Error('TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE');
-                    }
-                    writeReceipt(repoRoot, receipt);
-                    try {
-                        handoff.cleanup();
-                    }
-                    catch { /* keep the persisted canonical receipt usable */ }
-                }
-                catch (error) {
-                    return failed(resolved.taskId, {
-                        code: 'TASK_FINALIZATION_HANDOFF_INVALID',
-                        message: error instanceof Error ? error.message : String(error), retryable: false
-                    });
-                }
-            }
             if (!receipt)
                 return failed(resolved.taskId, {
                     code: 'TASK_FINALIZATION_PREPARATION_REQUIRED', message: 'sandbox preparation receipt is unavailable', retryable: true
                 });
+            if (options.controlBinding && !receipt.controlBinding) {
+                receipt = updateReceipt(repoRoot, receipt, { controlBinding: options.controlBinding });
+            }
             if (receipt.lifecycle === 'done' && receipt.verification !== 'pending' && resolved.state === 'completed') {
                 return terminalResult(resolved.taskId, receipt, { lifecycle: { status: 'no-op', changed: false, error: null } }, false);
             }
             if (options.controlBinding) {
                 const proof = inspectTaskLifecycleProgress(repoRoot, resolved.taskId, request.agent);
-                const oldBinding = receipt.controlBinding;
-                if (!oldBinding || oldBinding.generation !== options.controlBinding.generation || proof === 'unknown') {
+                if (proof === 'unknown') {
                     return failed(resolved.taskId, {
                         code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                        message: 'canonical receipt has no valid host recovery proof', retryable: false
+                        message: 'task lifecycle progress cannot be verified', retryable: false
                     });
                 }
-                if (oldBinding.requestId !== options.controlBinding.requestId && proof === 'not-started') {
-                    if (receipt.lifecycle !== 'pending' || !options.handoffDirectory || !request.handoffSha256) {
-                        return failed(resolved.taskId, {
-                            code: 'TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE',
-                            message: 'pending receipt cannot be rebound without a current handoff', retryable: false
-                        });
-                    }
-                    try {
-                        const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
-                        const nextReceipt = validateReceipt(handoff.receipt, resolved.taskId);
-                        if (nextReceipt.receiptId !== receipt.receiptId || nextReceipt.intent !== receipt.intent
-                            || nextReceipt.lifecycle !== 'pending')
-                            throw new Error('handoff is not continuous with canonical receipt');
-                        receipt = updateReceipt(repoRoot, receipt, { controlBinding: options.controlBinding });
-                        try {
-                            handoff.cleanup();
-                        }
-                        catch { /* keep the persisted canonical receipt usable */ }
-                    }
-                    catch (error) {
-                        return failed(resolved.taskId, {
-                            code: 'TASK_FINALIZATION_HANDOFF_INVALID',
-                            message: error instanceof Error ? error.message : String(error), retryable: false
-                        });
-                    }
-                }
             }
             if (receipt.taskComment === 'pending' || receipt.summary === 'pending' || receipt.warningProjection === 'pending') {
                 return failed(resolved.taskId, {