@fitlab-ai/agent-infra 0.11.9 → 0.11.10

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';
@@ -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

@@ -678,16 +678,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 +700,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 +710,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 +721,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 +747,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 +770,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,6 +969,7 @@ async function commitPreparedTaskFinalization(request, options) {
                 }
             }
             let receipt = readReceipt(repoRoot, resolved.taskId);
+            let importedHandoff = false;
             if (!receipt && options.controlBinding && options.handoffDirectory && request.handoffSha256) {
                 try {
                     const handoff = readTaskFinalizationHandoff(options.handoffDirectory, resolved.taskId, options.controlBinding, request.handoffSha256);
@@ -999,6 +980,7 @@ async function commitPreparedTaskFinalization(request, options) {
                         throw new Error('TASK_FINALIZATION_RECOVERY_PROOF_UNAVAILABLE');
                     }
                     writeReceipt(repoRoot, receipt);
+                    importedHandoff = true;
                     try {
                         handoff.cleanup();
                     }
@@ -1020,27 +1002,19 @@ async function commitPreparedTaskFinalization(request, options) {
             }
             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
-                        });
-                    }
+                if (!importedHandoff && options.handoffDirectory && request.handoffSha256) {
                     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')
+                            || nextReceipt.lifecycle !== receipt.lifecycle)
                             throw new Error('handoff is not continuous with canonical receipt');
-                        receipt = updateReceipt(repoRoot, receipt, { controlBinding: options.controlBinding });
                         try {
                             handoff.cleanup();
                         }

package/dist/lib/task/frontmatter.js

@@ -47,7 +47,7 @@ function serializeScalar(value) {
     }
     if (value === '')
         return '';
-    const serialized = stringify(value).trimEnd();
+    const serialized = stringify(value, { lineWidth: 0 }).trimEnd();
     if (serialized.includes('\n') || serialized.includes('\r')) {
         throw new FrontmatterError('MUTATION_INVALID', 'frontmatter values must be scalar');
     }

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

@@ -10,6 +10,7 @@ import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkInten
 import { extractSection, extractSubSection } from './sections.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { scanVisibleMarkdown } from './markdown.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 const PREFIX = { analysis: 'AN', plan: 'PL', code: 'CD' };
 const RESPONSE = new Set(['accepted', 'adjusted', 'refuted', 'cannot-judge']);
 const DISPOSITION = new Set(['confirmed', 'closed', 'open', 'needs-human-decision']);
@@ -61,9 +62,8 @@ function findingEvidence(reviewContent, evidence) {
     return semanticFindingEvidence(reviewContent, heading, next?.start ?? reviewContent.length);
 }
 function taskFactDigest(taskDir, content) {
-    const analysisNames = fs.readdirSync(taskDir).filter((name) => /^analysis(?:-r\d+)?\.md$/.test(name));
-    const latest = analysisNames.map((name) => ({ name, round: parseArtifactName(name)?.round ?? 0 })).sort((a, b) => b.round - a.round)[0];
-    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latest.name), 'utf8')) : null;
+    const latest = inspectArtifactDirectory(taskDir, 'analysis').latest;
+    const flow = latest ? parseLifecyclePathDecision(fs.readFileSync(latest.path, 'utf8'), latest.name) : null;
     return semanticDigest(JSON.stringify({
         taskInput: normalizedTaskFact(extractSection(content, ['任务输入', 'Task Input'])),
         requirements: normalizedTaskFact(extractSection(content, ['需求', 'Requirements'])),
@@ -220,10 +220,7 @@ function applyLedgerIntent(intent, options = {}) {
             }
             const sourceIdentity = parseArtifactName(intent.sourceArtifact);
             const expectedFamily = `review-${finding.stage}`;
-            const latestSource = fs.readdirSync(resolved.taskDir)
-                .map((name) => parseArtifactName(name))
-                .filter((identity) => identity?.family === expectedFamily)
-                .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0];
+            const latestSource = inspectArtifactDirectory(resolved.taskDir, expectedFamily).latest;
             if (!sourceIdentity || sourceIdentity.family !== expectedFamily || latestSource?.name !== sourceIdentity.name) {
                 return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact is not the latest review for the finding stage', resolved.taskId);
             }

package/dist/lib/task/orchestration.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
-import { artifactName, maxArtifactRound } from './artifact-name.js';
+import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
@@ -20,7 +20,6 @@ import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead,
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
 import { hasOpenLifecycleExecution } from './activity-log.js';
-import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { resolveArtifactContext } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
@@ -441,8 +440,11 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
     return { status: 'running', changed: true, taskId: resolved.taskId, run, next: null, error: null };
 }
 function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead) {
-    const reviewRound = maxArtifactRound(fs.readdirSync(taskDir), 'review-code');
-    const reviewContent = fs.readFileSync(path.join(taskDir, artifactName('review-code', reviewRound)), 'utf8');
+    const reviewInventory = inspectArtifactDirectory(taskDir, 'review-code');
+    if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+        return { code: 'ORCHESTRATION_REVIEW_INVALID', message: 'latest completed review-code artifact is unavailable' };
+    }
+    const reviewContent = fs.readFileSync(reviewInventory.latest.path, 'utf8');
     const savedTargetHead = extractReviewTargetHead(reviewContent);
     const savedDiffBase = extractReviewDiffBase(reviewContent);
     const savedReviewedHead = extractReviewedHead(reviewContent) || extractReviewBaseline(reviewContent);
@@ -540,8 +542,11 @@ function routeOrchestration(taskRef, options = {}) {
         if (facts.facts.executionBusy && !run?.pendingDelegation) {
             return failed('ORCHESTRATION_EXECUTION_BUSY', 'clean completion requires no open lifecycle execution', resolved.taskId);
         }
-        const reviewRound = maxArtifactRound(fs.readdirSync(resolved.taskDir), 'review-code');
-        const review = parseReviewSummary(fs.readFileSync(path.join(resolved.taskDir, artifactName('review-code', reviewRound)), 'utf8'));
+        const reviewInventory = inspectArtifactDirectory(resolved.taskDir, 'review-code');
+        if (reviewInventory.status !== 'ready' || !reviewInventory.latest) {
+            return failed('ORCHESTRATION_REVIEW_INVALID', 'latest completed review-code artifact is unavailable', resolved.taskId);
+        }
+        const review = parseReviewSummary(fs.readFileSync(reviewInventory.latest.path, 'utf8'));
         if (!review.ok || review.summary.manualValidation === null) {
             return failed('ORCHESTRATION_REVIEW_INVALID', 'latest code review has no numeric manual-validation count', resolved.taskId);
         }
@@ -678,10 +683,6 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     if (run.stepCount >= run.maxSteps)
         return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
-    const invalidation = reconcileTaskInvalidation(taskRef, { repoRoot: resolved.repoRoot });
-    if (invalidation.status === 'failed') {
-        return failed('ORCHESTRATION_INVALIDATION_RECONCILE_FAILED', `${invalidation.error?.code ?? 'UNKNOWN'}: ${invalidation.error?.message ?? ''}`, resolved.taskId);
-    }
     const routed = routeOrchestration(taskRef, options);
     if (!routed.next)
         return routed;