@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/dist/lib/task/intermediate-cleanup.js

@@ -7,17 +7,10 @@ import { checkpointCommitMatches } from './commit-identity.js';
 import { readCheckpointIntent } from './commit-intent.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { readTaskFinalizationReceipt } from './finalization.js';
-import { semanticDigest, sha256Content } from './local-artifact-finalization.js';
-import { artifactRecoveryRoot, readArtifactRecoveryIntent } from './artifact-repair-intent.js';
-import { parseArtifactName } from './artifact-name.js';
 import { enumerateAllTaskDirs } from './resolve-ref.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const LOCAL_INTENT_RE = /^(TASK-\d{8}-\d{6})-(analysis|review-analysis|plan|review-plan|code|review-code)-(.+\.md)\.json$/;
 const COMMIT_INTENT_RE = /^(TASK-\d{8}-\d{6})\.json$/;
-const AUXILIARY_ROOTS = [
-    '.local-artifact-finalization-intents',
-    '.task-commit-intents'
-];
+const AUXILIARY_ROOTS = ['.task-commit-intents'];
 function auxiliaryRoot(repoRoot, name) {
     return path.join(repoRoot, '.agents', 'workspace', name);
 }
@@ -98,46 +91,6 @@ function receiptGate(repoRoot, task, options) {
     }
     return null;
 }
-function canonicalLocalIntentPath(taskId, family, artifact) {
-    return `${taskId}-${family}-${artifact}.json`;
-}
-function localIntentCandidate(repoRoot, task, filePath, taskId, family, artifact, identity, options) {
-    const protectedReason = taskGate(task);
-    if (protectedReason)
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', protectedReason, identity);
-    if (path.basename(filePath) !== canonicalLocalIntentPath(taskId, family, artifact)
-        || !parseArtifactName(artifact)?.family || parseArtifactName(artifact).family !== family) {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity);
-    }
-    let intent;
-    try {
-        intent = readArtifactRecoveryIntent(repoRoot, taskId, family, artifact);
-    }
-    catch {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'LFAI_SCHEMA_INVALID', identity);
-    }
-    if (!intent || intent.state !== 'consumed') {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'LFAI_STATE_PROTECTED', identity);
-    }
-    const artifactPath = path.join(task.taskDir, artifact);
-    if (safeLstat(task.taskDir, artifactPath, 'file') === null) {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_IDENTITY_MISMATCH', identity);
-    }
-    let content;
-    try {
-        content = fs.readFileSync(artifactPath, 'utf8');
-    }
-    catch {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_UNREADABLE', identity);
-    }
-    if (intent.finalArtifactSha256 !== sha256Content(content) || intent.finalSemanticDigest !== semanticDigest(content)) {
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', 'ARTIFACT_DIGEST_MISMATCH', identity);
-    }
-    const receiptReason = receiptGate(repoRoot, task, options);
-    if (receiptReason)
-        return item('LFAI-CONSUMED', taskId, filePath, 'protected', receiptReason, identity);
-    return item('LFAI-CONSUMED', taskId, filePath, 'planned', 'LFAI_CONSUMED_AND_VERIFIED', identity);
-}
 function commitIntentCandidate(repoRoot, task, filePath, taskId, identity, options) {
     const protectedReason = taskGate(task);
     if (protectedReason)
@@ -209,24 +162,13 @@ function readAuxiliaryCandidates(repoRoot, tasks, options) {
                 candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH'));
                 continue;
             }
-            if (rootName === '.local-artifact-finalization-intents') {
-                const match = LOCAL_INTENT_RE.exec(entry.name);
-                if (!match || (selected && !selected.has(match[1]))) {
-                    if (!selected || !match)
-                        candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity));
-                    continue;
-                }
-                candidates.push(localIntentCandidate(repoRoot, tasks.get(match[1]), filePath, match[1], match[2], match[3], identity, options));
-            }
-            else {
-                const match = COMMIT_INTENT_RE.exec(entry.name);
-                if (!match || (selected && !selected.has(match[1]))) {
-                    if (!selected || !match)
-                        candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity));
-                    continue;
-                }
-                candidates.push(commitIntentCandidate(repoRoot, tasks.get(match[1]), filePath, match[1], identity, options));
+            const match = COMMIT_INTENT_RE.exec(entry.name);
+            if (!match || (selected && !selected.has(match[1]))) {
+                if (!selected || !match)
+                    candidates.push(item('AUXILIARY-UNKNOWN', null, filePath, 'protected', 'PATH_IDENTITY_MISMATCH', identity));
+                continue;
             }
+            candidates.push(commitIntentCandidate(repoRoot, tasks.get(match[1]), filePath, match[1], identity, options));
         }
         if (entries.length === 0) {
             candidates.push(item('EMPTY-AUX-PARENT', null, root, 'planned', 'EMPTY_CANONICAL_AUXILIARY_ROOT', rootIdentity));
@@ -255,85 +197,7 @@ function scanIntermediateCleanup(repoRoot, options = {}) {
     const candidates = scanInternal(repoRoot, options);
     return buildIntermediateCleanupReport(candidates, true);
 }
-function cleanupConsumedRecoveryFiles(repoRoot, task, candidate) {
-    if (candidate.kind !== 'LFAI-CONSUMED' || !candidate.taskId)
-        return true;
-    if (!task)
-        return false;
-    const match = LOCAL_INTENT_RE.exec(path.basename(candidate.path));
-    if (!match)
-        return false;
-    let intent;
-    try {
-        intent = readArtifactRecoveryIntent(repoRoot, candidate.taskId, match[2], match[3]);
-    }
-    catch {
-        return false;
-    }
-    if (!intent || intent.state !== 'consumed')
-        return false;
-    const recovery = artifactRecoveryRoot(task.taskDir, intent.recoveryOperationId);
-    let stat = null;
-    try {
-        stat = fs.lstatSync(recovery);
-    }
-    catch (error) {
-        if (errorCode(error) === 'ENOENT')
-            return true;
-        return false;
-    }
-    if (!stat.isDirectory() || stat.isSymbolicLink())
-        return false;
-    let entries;
-    try {
-        entries = fs.readdirSync(recovery, { withFileTypes: true });
-    }
-    catch {
-        return false;
-    }
-    for (const entry of entries) {
-        if (entry.isSymbolicLink())
-            return false;
-        if (entry.isFile()) {
-            if (!['baseline.md', 'candidate.md', 'final.md', 'publish.md'].includes(entry.name))
-                return false;
-            continue;
-        }
-        if (!entry.isDirectory() || entry.name !== 'generations')
-            return false;
-        let generations;
-        try {
-            generations = fs.readdirSync(path.join(recovery, entry.name), { withFileTypes: true });
-        }
-        catch {
-            return false;
-        }
-        if (generations.some((generation) => generation.isSymbolicLink()
-            || !generation.isFile() || !/^[a-f0-9]{64}\.md$/u.test(generation.name)))
-            return false;
-    }
-    try {
-        for (const entry of entries) {
-            const target = path.join(recovery, entry.name);
-            if (entry.isFile())
-                fs.unlinkSync(target);
-            else {
-                for (const generation of fs.readdirSync(target, { withFileTypes: true }))
-                    fs.unlinkSync(path.join(target, generation.name));
-                fs.rmdirSync(target);
-            }
-        }
-        fs.rmdirSync(recovery);
-        const recoveryRoot = path.dirname(recovery);
-        if (fs.readdirSync(recoveryRoot).length === 0)
-            fs.rmdirSync(recoveryRoot);
-        return true;
-    }
-    catch (error) {
-        return errorCode(error) === 'ENOENT';
-    }
-}
-function removeCandidate(repoRoot, candidate, task) {
+function removeCandidate(repoRoot, candidate) {
     if (candidate.disposition !== 'planned')
         return candidate;
     const root = candidate.kind === 'EMPTY-AUX-PARENT'
@@ -358,9 +222,6 @@ function removeCandidate(repoRoot, candidate, task) {
         return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_CHANGED' };
     if (!sameFileIdentity(expected, actual))
         return { ...candidate, disposition: 'protected', reason: 'PATH_IDENTITY_CHANGED' };
-    if (!cleanupConsumedRecoveryFiles(repoRoot, task, candidate)) {
-        return { ...candidate, disposition: 'protected', reason: 'RECOVERY_STAGING_NOT_SAFE_TO_REMOVE' };
-    }
     try {
         if (candidate.kind === 'EMPTY-AUX-PARENT') {
             if (fs.readdirSync(candidate.path).length !== 0)
@@ -413,7 +274,7 @@ function cleanupIntermediateUnderRemovalCoordinator(repoRoot, options = {}) {
                     continue;
                 const current = refreshedByKey.get(intermediateCleanupKey(initialCandidate));
                 items[index] = current
-                    ? removeCandidate(repoRoot, current, tasks.get(taskId))
+                    ? removeCandidate(repoRoot, current)
                     : { ...initialCandidate, disposition: 'protected', reason: 'CANDIDATE_NO_LONGER_ELIGIBLE' };
             }
         };

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

@@ -6,8 +6,10 @@ import { parseArtifactName } from './artifact-name.js';
 import { LEDGER_COLUMNS, LEDGER_HEADINGS, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, nextHdId, parseLedgerDocument, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
-import { parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
+import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.js';
+import { extractSection, extractSubSection } from './sections.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
+import { scanVisibleMarkdown } from './markdown.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']);
@@ -23,15 +25,50 @@ function ledgerReadErrorCode(error) {
         return code;
     return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
 }
-function maxHandshakeRounds(repoRoot) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8'));
-        const value = parsed.review?.maxHandshakeRounds;
-        return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 3;
-    }
-    catch {
-        return 3;
+const CLASSIFICATION_TARGET = {
+    'scope-or-requirement': 'analysis', design: 'plan', implementation: 'code',
+    'human-decision': 'pause', 'insufficient-evidence': 'pause'
+};
+function semanticDigest(value) {
+    return createHash('sha256').update(value.normalize('NFKC').replace(/\s+/g, ' ').trim()).digest('hex');
+}
+function normalizedTaskFact(value) {
+    return value.normalize('NFKC').replace(/\s+/g, ' ').trim();
+}
+function semanticFindingEvidence(reviewContent, heading, end) {
+    const title = heading.text.replace(/^\d+[.、：:]\s*/, '').trim();
+    return `${title}\n${reviewContent.slice(heading.end, end)}`;
+}
+function findingEvidence(reviewContent, evidence) {
+    const anchor = evidence.split('#')[1];
+    if (!anchor)
+        return null;
+    const markdown = scanVisibleMarkdown(reviewContent);
+    const explicit = markdown.anchors.find((candidate) => candidate.id === anchor);
+    if (explicit) {
+        const heading = markdown.headings.find((candidate) => candidate.start > explicit.start);
+        const next = heading && markdown.headings.find((candidate) => candidate.start > heading.start && candidate.level <= heading.level);
+        const end = next?.start ?? reviewContent.length;
+        return heading ? semanticFindingEvidence(reviewContent, heading, end) : reviewContent.slice(explicit.end, end);
     }
+    const heading = markdown.headings.find((candidate) => {
+        const escapedAnchor = anchor.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return candidate.text === anchor || new RegExp(`^${escapedAnchor}(?:\\s|[.、：:])`).test(candidate.text);
+    });
+    if (!heading)
+        return null;
+    const next = markdown.headings.find((candidate) => candidate.start > heading.start && candidate.level <= heading.level);
+    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;
+    return semanticDigest(JSON.stringify({
+        taskInput: normalizedTaskFact(extractSection(content, ['任务输入', 'Task Input'])),
+        requirements: normalizedTaskFact(extractSection(content, ['需求', 'Requirements'])),
+        flow: flow?.status === 'valid' ? flow.decision.semanticDigest : flow?.status ?? 'missing'
+    }));
 }
 function nextFindingId(rows, stage) {
     const prefix = PREFIX[stage];
@@ -67,8 +104,7 @@ function applyLedgerIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    const stateOverride = allowsManualOverride(options.manualOverride, 'ledger-intent', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -89,12 +125,15 @@ function applyLedgerIntent(intent, options = {}) {
         return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: nextHdId(rows), before: null, after: null, operations: [], error: null };
     }
     if (intent.kind === 'rework-intent-upsert') {
-        if (!/^RI-[1-9]\d*$/.test(intent.intentId) || !/^(AN|PL|CD)-[1-9]\d*$/.test(intent.findingId) || !['analysis', 'plan', 'code'].includes(intent.target) || !/^[a-f0-9]{64}$/.test(intent.sourceSha256)) {
-            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rework intent identity, target, or source hash is invalid', resolved.taskId, intent.intentId);
+        if (!/^RI-[1-9]\d*$/.test(intent.intentId) || !/^(AN|PL|CD)-[1-9]\d*$/.test(intent.findingId) || !(intent.classification in CLASSIFICATION_TARGET) || !/^[a-f0-9]{64}$/.test(intent.sourceSha256)) {
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rework intent identity, classification, or source hash is invalid', resolved.taskId, intent.intentId);
         }
         const finding = rows.find((row) => row.id === intent.findingId);
         if (!finding || finding.severity === 'decision')
             return failed(intent, 'LEDGER_NOT_FOUND', `finding '${intent.findingId}' was not found`, resolved.taskId, intent.findingId);
+        if (intent.classification === 'human-decision' && finding.status !== 'needs-human-decision') {
+            return failed(intent, 'LEDGER_TRANSITION_INVALID', 'human-decision classification requires a needs-human-decision finding', resolved.taskId, intent.findingId);
+        }
         const sourceFromEvidence = finding.evidence.split('#')[0];
         if (sourceFromEvidence !== intent.sourceArtifact || parseArtifactName(intent.sourceArtifact)?.family !== `review-${finding.stage}`) {
             return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact does not match finding evidence', resolved.taskId, intent.intentId);
@@ -106,12 +145,35 @@ function applyLedgerIntent(intent, options = {}) {
             const parsed = parseReworkIntentDocument(content);
             if (!parsed.ok)
                 return failed(intent, parsed.code, parsed.message, resolved.taskId, intent.intentId);
-            const nextIntent = {
+            const reviewContent = fs.readFileSync(path.join(resolved.taskDir, intent.sourceArtifact), 'utf8');
+            const evidenceBlock = findingEvidence(reviewContent, finding.evidence);
+            if (!evidenceBlock)
+                return failed(intent, 'LEDGER_EVIDENCE_INVALID', `finding evidence anchor '${finding.evidence}' was not found`, resolved.taskId, intent.intentId);
+            const evidenceDigest = semanticDigest(evidenceBlock);
+            const factsDigest = taskFactDigest(resolved.taskDir, content);
+            const requestedIntent = {
                 intentId: intent.intentId, findingId: intent.findingId, sourceArtifact: intent.sourceArtifact,
-                sourceSha256: intent.sourceSha256, target: intent.target, status: 'pending',
+                sourceSha256: intent.sourceSha256, target: CLASSIFICATION_TARGET[intent.classification], classification: intent.classification,
+                evidenceDigest, taskFactDigest: factsDigest, status: 'pending',
                 declaredAt: new Date().toISOString(), consumedAt: ''
             };
-            const next = upsertReworkIntent(parsed.intents, nextIntent);
+            if (parsed.intents.some((candidate) => candidate.intentId === intent.intentId)) {
+                const replay = upsertReworkIntent(parsed.intents, requestedIntent);
+                if (!replay.changed) {
+                    return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: intent.intentId, before: null, after: null, operations: [], error: null };
+                }
+            }
+            const same = parsed.intents.find((candidate) => candidate.findingId === intent.findingId
+                && candidate.evidenceDigest === evidenceDigest && candidate.taskFactDigest === factsDigest
+                && candidate.classification === intent.classification && candidate.target === CLASSIFICATION_TARGET[intent.classification]);
+            const classification = same ? 'insufficient-evidence' : intent.classification;
+            const nextIntent = {
+                ...requestedIntent, target: CLASSIFICATION_TARGET[classification], classification
+            };
+            const now = nextIntent.declaredAt;
+            const superseded = parsed.intents.map((candidate) => candidate.status === 'pending'
+                ? { ...candidate, status: 'superseded', consumedAt: now } : candidate);
+            const next = upsertReworkIntent(superseded, nextIntent);
             if (!next.changed)
                 return { status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: intent.intentId, before: null, after: null, operations: [], error: null };
             const result = writeTask({ taskRef: intent.taskRef, expectedState: 'active', dryRun: intent.dryRun, mutations: [reworkIntentMutation(content, next.intents)] }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
@@ -123,6 +185,84 @@ function applyLedgerIntent(intent, options = {}) {
             return failed(intent, 'LEDGER_IDENTITY_CONFLICT', error instanceof Error ? error.message : String(error), resolved.taskId, intent.intentId);
         }
     }
+    if (intent.kind === 'rework-intent-rebuild') {
+        const beforeSha256 = createHash('sha256').update(content).digest('hex');
+        const supplied = [intent.findingId, intent.sourceArtifact, intent.sourceSha256, intent.classification].filter((value) => value !== undefined).length;
+        if (supplied !== 0 && supplied !== 4)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rebuild binding options must be provided together', resolved.taskId);
+        const current = parseReworkIntentDocument(content);
+        if (current.ok && current.present) {
+            if (supplied !== 0)
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'current rework intent format does not accept rebuild binding options', resolved.taskId);
+            return {
+                status: 'no-op', changed: false, intent: intent.kind, taskId: resolved.taskId, entityId: null,
+                before: null, after: null, operations: [], error: null,
+                rebuild: { mode: 'format-only', beforeSha256, afterSha256: beforeSha256, converted: current.intents.length, newIntentId: null }
+            };
+        }
+        const legacy = parseLegacyReworkIntentDocument(content);
+        if (!legacy.ok)
+            return failed(intent, legacy.code, legacy.message, resolved.taskId);
+        const pending = legacy.intents.filter((row) => row.status === 'pending');
+        if (pending.length === 0 && supplied !== 0)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'format-only rebuild does not accept finding or classification options', resolved.taskId);
+        if (pending.length > 0 && supplied !== 4)
+            return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'legacy pending intents require finding, review, hash, and classification', resolved.taskId);
+        const now = new Date().toISOString();
+        let next = legacy.intents.map((row) => row.status === 'pending' ? { ...row, status: 'superseded', consumedAt: now } : row);
+        let entityId = null;
+        if (pending.length > 0) {
+            const finding = rows.find((row) => row.id === intent.findingId);
+            if (!finding || finding.severity === 'decision' || finding.evidence.split('#')[0] !== intent.sourceArtifact)
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild binding does not match a review finding', resolved.taskId);
+            if (intent.classification === 'human-decision' && finding.status !== 'needs-human-decision') {
+                return failed(intent, 'LEDGER_TRANSITION_INVALID', 'human-decision classification requires a needs-human-decision finding', resolved.taskId);
+            }
+            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];
+            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);
+            }
+            const sourcePath = path.join(resolved.taskDir, intent.sourceArtifact);
+            const actualHash = createHash('sha256').update(fs.readFileSync(sourcePath)).digest('hex');
+            if (actualHash !== intent.sourceSha256)
+                return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rebuild source artifact hash does not match', resolved.taskId);
+            const max = next.reduce((value, row) => Math.max(value, Number(row.intentId.slice(3))), 0);
+            entityId = `RI-${max + 1}`;
+            const reviewContent = fs.readFileSync(sourcePath, 'utf8');
+            const classification = intent.classification;
+            if (!(classification in CLASSIFICATION_TARGET))
+                return failed(intent, 'LEDGER_PAYLOAD_INVALID', 'rebuild classification is invalid', resolved.taskId);
+            const evidenceBlock = findingEvidence(reviewContent, finding.evidence);
+            if (!evidenceBlock)
+                return failed(intent, 'LEDGER_EVIDENCE_INVALID', `finding evidence anchor '${finding.evidence}' was not found`, resolved.taskId);
+            next = [...next, {
+                    intentId: entityId, findingId: intent.findingId, sourceArtifact: intent.sourceArtifact, sourceSha256: intent.sourceSha256,
+                    target: CLASSIFICATION_TARGET[classification], classification,
+                    evidenceDigest: semanticDigest(evidenceBlock),
+                    taskFactDigest: taskFactDigest(resolved.taskDir, content), status: 'pending', declaredAt: now, consumedAt: ''
+                }];
+        }
+        const result = writeTask({ taskRef: intent.taskRef, expectedState: 'active', dryRun: intent.dryRun, mutations: [reworkIntentMutation(content, next)] }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });
+        if (result.status === 'failed')
+            return failed(intent, result.error.code, result.error.message, result.taskId, entityId);
+        const afterContent = result.status === 'applied' || result.status === 'no-op' ? fs.readFileSync(resolved.taskMdPath, 'utf8') : content;
+        return {
+            status: result.status, changed: result.changed, intent: intent.kind, taskId: result.taskId, entityId,
+            before: null, after: null, operations: result.operations, error: null,
+            rebuild: {
+                mode: pending.length > 0 ? 'pending-reclassification' : 'format-only',
+                beforeSha256,
+                afterSha256: createHash('sha256').update(afterContent).digest('hex'),
+                converted: legacy.intents.length,
+                newIntentId: entityId
+            }
+        };
+    }
     let before = null;
     let after;
     if (intent.kind === 'finding-upsert') {
@@ -199,8 +339,7 @@ function applyLedgerIntent(intent, options = {}) {
                         ? new Set(['confirmed', 'open', 'needs-human-decision'])
                         : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set();
                 const sameRoundMinorClose = before.status === 'open' && before.severity === 'minor' && intent.status === 'closed';
-                if (((!sameRoundMinorClose && !allowed.has(intent.status)) || (intent.status === 'open' && Number(before.round) >= maxHandshakeRounds(resolved.repoRoot)))
-                    && !allowsManualOverride(options.manualOverride, 'ledger-intent', 'LEDGER_TRANSITION_INVALID')) {
+                if (!sameRoundMinorClose && !allowed.has(intent.status)) {
                     return failed(intent, 'LEDGER_TRANSITION_INVALID', `finding '${intent.id}' cannot transition from ${before.status} to ${intent.status}`, resolved.taskId, intent.id);
                 }
                 after = { ...before, status: intent.status, evidence };
@@ -233,7 +372,7 @@ function applyLedgerIntent(intent, options = {}) {
         }
     }
     const result = writeTask({
-        taskRef: intent.taskRef, expectedState: stateOverride ? resolved.state : 'active',
+        taskRef: intent.taskRef, expectedState: 'active',
         mutations: [rowMutation(after), ...(implementationMutation ? [implementationMutation] : [])],
         dryRun: 'dryRun' in intent ? intent.dryRun : false
     }, { ...options, taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state } });

package/dist/lib/task/lifecycle-path.js

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { extractSection } from './sections.js';
+const PATH_STAGES = {
+    streamlined: ['analysis', 'code', 'review-code'],
+    standard: ['analysis', 'plan', 'code', 'review-code'],
+    full: ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']
+};
+const FIELD_ALIASES = {
+    path: ['本任务路径', 'Path'],
+    basis: ['判定依据', 'Basis'],
+    unmetHigherConditions: ['未满足的更高路径条件', '未满足的较低路径条件', 'Unmet Higher-path Conditions'],
+    upgradeTriggers: ['升级触发条件', 'Upgrade Triggers']
+};
+function normalizeText(value) {
+    return value.normalize('NFKC').replace(/\s+/g, ' ').trim().replace(/[。.]$/, '');
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function pathToken(value) {
+    const normalized = normalizeText(value).toLowerCase().replace(/[`*_]/g, '');
+    if (/^(?:streamlined|精简路径|精简)$/.test(normalized))
+        return 'streamlined';
+    if (/^(?:standard|标准路径|标准)$/.test(normalized))
+        return 'standard';
+    if (/^(?:full|完整路径|完整)$/.test(normalized))
+        return 'full';
+    return null;
+}
+function fieldValues(body, aliases) {
+    const wanted = new Set(aliases);
+    const values = [];
+    for (const line of body.split(/\r?\n/)) {
+        const match = /^\s*[-*]\s+\*\*([^*]+)\*\*[:：]\s*(.*?)\s*$/.exec(line);
+        if (match && wanted.has(match[1].trim()))
+            values.push(match[2].trim());
+    }
+    return values;
+}
+function parseLifecyclePathDecision(analysisContent, sourceArtifact = '', sourceSha256 = '') {
+    const body = extractSection(analysisContent, ['流程裁定', 'Flow Decision']);
+    if (!body)
+        return { status: 'missing', decision: null, message: 'analysis flow decision section is missing' };
+    const fields = Object.fromEntries(Object.entries(FIELD_ALIASES).map(([key, aliases]) => [key, fieldValues(body, aliases)]));
+    const invalid = Object.entries(fields).find(([, values]) => values.length !== 1);
+    if (invalid)
+        return { status: 'invalid', decision: null, message: `flow decision field '${invalid[0]}' must appear exactly once` };
+    const path = pathToken(fields.path[0]);
+    if (!path)
+        return { status: 'invalid', decision: null, message: `unknown lifecycle path '${fields.path[0]}'` };
+    const basis = normalizeText(fields.basis[0]);
+    const unmetHigherConditions = normalizeText(fields.unmetHigherConditions[0]);
+    const upgradeTriggers = normalizeText(fields.upgradeTriggers[0]);
+    if (!basis || !unmetHigherConditions || !upgradeTriggers)
+        return { status: 'invalid', decision: null, message: 'flow decision fields must be non-empty' };
+    return {
+        status: 'valid',
+        message: null,
+        decision: {
+            path,
+            stages: PATH_STAGES[path],
+            basis,
+            unmetHigherConditions,
+            upgradeTriggers,
+            semanticDigest: digest({ path, basis, unmetHigherConditions, upgradeTriggers }),
+            sourceArtifact,
+            sourceSha256
+        }
+    };
+}
+function pathIncludes(state, stage) {
+    return state?.status === 'valid' && state.decision.stages.includes(stage);
+}
+export { PATH_STAGES, parseLifecyclePathDecision, pathIncludes };
+//# sourceMappingURL=lifecycle-path.js.map