@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/lib/task/intermediate-cleanup.ts

@@ -14,26 +14,14 @@ import {
   readTaskFinalizationReceipt,
   type TaskFinalizationReceipt
 } from './finalization.ts';
-import {
-  semanticDigest,
-  sha256Content
-} from './local-artifact-finalization.ts';
-import { artifactRecoveryRoot, readArtifactRecoveryIntent } from './artifact-repair-intent.ts';
-import type { ArtifactRecoveryIntent } from './artifact-repair-intent.ts';
-import { parseArtifactName } from './artifact-name.ts';
-import type { ArtifactSchemaFamily } from './artifact-schema.ts';
 import { enumerateAllTaskDirs, type TaskWorkspaceState } from './resolve-ref.ts';
 import type { TaskControlBindingEvidence } from './finalization-state.ts';
 
 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'
-] as const;
+const AUXILIARY_ROOTS = ['.task-commit-intents'] as const;
 
-type CleanupKind = 'LFAI-CONSUMED' | 'COMMIT-SYNCED' | 'EMPTY-AUX-PARENT';
+type CleanupKind = 'COMMIT-SYNCED' | 'EMPTY-AUX-PARENT';
 type CleanupDisposition = 'planned' | 'protected' | 'skipped' | 'deleted' | 'failed';
 type FileIdentity = Readonly<{ dev: string; ino: string; size: number; mtimeMs: number }>;
 
@@ -153,47 +141,6 @@ function receiptGate(
   return null;
 }
 
-function canonicalLocalIntentPath(taskId: string, family: string, artifact: string): string {
-  return `${taskId}-${family}-${artifact}.json`;
-}
-
-function localIntentCandidate(
-  repoRoot: string,
-  task: TaskRecord | undefined,
-  filePath: string,
-  taskId: string,
-  family: ArtifactSchemaFamily,
-  artifact: string,
-  identity: FileIdentity,
-  options: ScanOptions
-): IntermediateCleanupItem {
-  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: ArtifactRecoveryIntent | null;
-  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: string;
-  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: string,
   task: TaskRecord | undefined,
@@ -258,23 +205,12 @@ function readAuxiliaryCandidates(
         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] as 'analysis' | 'plan' | 'code', 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));
@@ -307,56 +243,7 @@ function scanIntermediateCleanup(repoRoot: string, options: ScanOptions = {}): I
   return buildIntermediateCleanupReport(candidates, true);
 }
 
-function cleanupConsumedRecoveryFiles(repoRoot: string, task: TaskRecord | undefined, candidate: IntermediateCleanupItem): boolean {
-  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: ReturnType<typeof readArtifactRecoveryIntent>;
-  try { intent = readArtifactRecoveryIntent(repoRoot, candidate.taskId, match[2] as ArtifactSchemaFamily, match[3]!); }
-  catch { return false; }
-  if (!intent || intent.state !== 'consumed') return false;
-
-  const recovery = artifactRecoveryRoot(task.taskDir, intent.recoveryOperationId);
-  let stat: fs.Stats | null = 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: fs.Dirent[];
-  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: fs.Dirent[];
-    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: string, candidate: IntermediateCleanupItem, task?: TaskRecord): IntermediateCleanupItem {
+function removeCandidate(repoRoot: string, candidate: IntermediateCleanupItem): IntermediateCleanupItem {
   if (candidate.disposition !== 'planned') return candidate;
   const root = candidate.kind === 'EMPTY-AUX-PARENT'
     ? path.dirname(path.dirname(candidate.path))
@@ -373,9 +260,6 @@ function removeCandidate(repoRoot: string, candidate: IntermediateCleanupItem, t
   const actual = safeLstat(root, candidate.path, candidate.kind === 'EMPTY-AUX-PARENT' ? 'directory' : 'file');
   if (!actual) 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) return { ...candidate, disposition: 'protected', reason: 'AUXILIARY_ROOT_NOT_EMPTY' };
@@ -434,7 +318,7 @@ function cleanupIntermediateUnderRemovalCoordinator(
         if (initialCandidate.disposition !== 'planned') 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/lib/task/ledger-intents.ts

@@ -14,9 +14,11 @@ import type { LedgerRow, ReviewStage } from './ledger.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import { writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
-import { allowsManualOverride } from './guard-override.ts';
-import { parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.ts';
-import type { ReworkIntent, ReworkTarget } from './rework-intent.ts';
+import { parseLegacyReworkIntentDocument, parseReworkIntentDocument, reworkIntentMutation, upsertReworkIntent } from './rework-intent.ts';
+import type { ReworkClassification, ReworkIntent, ReworkTarget } from './rework-intent.ts';
+import { extractSection, extractSubSection } from './sections.ts';
+import { parseLifecyclePathDecision } from './lifecycle-path.ts';
+import { scanVisibleMarkdown } from './markdown.ts';
 
 type ReviewSeverity = 'blocker' | 'major' | 'minor';
 type ExecutorResponse = 'accepted' | 'adjusted' | 'refuted' | 'cannot-judge';
@@ -27,7 +29,8 @@ type LedgerIntent =
   | { kind: 'finding-review'; taskRef: string; id: string; status: ReviewDisposition; evidence: string; needsImplementation?: boolean; dryRun?: boolean }
   | { kind: 'decision-next-id'; taskRef: string }
   | { kind: 'decision-upsert'; taskRef: string; id: string; stage: ReviewStage; artifact: string; needsImplementation?: boolean; dryRun?: boolean }
-  | { kind: 'rework-intent-upsert'; taskRef: string; intentId: string; findingId: string; sourceArtifact: string; sourceSha256: string; target: ReworkTarget; dryRun?: boolean };
+  | { kind: 'rework-intent-upsert'; taskRef: string; intentId: string; findingId: string; sourceArtifact: string; sourceSha256: string; classification: ReworkClassification; dryRun?: boolean }
+  | { kind: 'rework-intent-rebuild'; taskRef: string; findingId?: string; sourceArtifact?: string; sourceSha256?: string; classification?: ReworkClassification; dryRun?: boolean };
 
 type LedgerIntentError = { code: string; message: string };
 type LedgerIntentResult = {
@@ -39,6 +42,7 @@ type LedgerIntentResult = {
   before: LedgerRow | null;
   after: LedgerRow | null;
   operations: readonly TaskOperationSummary[];
+  rebuild?: Readonly<{ mode: 'format-only' | 'pending-reclassification'; beforeSha256: string; afterSha256: string; converted: number; newIntentId: string | null }>;
   error: LedgerIntentError | null;
 };
 
@@ -60,12 +64,53 @@ function ledgerReadErrorCode(error: unknown): string {
   return code === 'TABLE_DUPLICATE_KEY' ? 'LEDGER_DUPLICATE_ID' : 'LEDGER_DOCUMENT_INVALID';
 }
 
-function maxHandshakeRounds(repoRoot: string): number {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(path.join(repoRoot, '.agents', '.airc.json'), 'utf8')) as { review?: { maxHandshakeRounds?: unknown } };
-    const value = parsed.review?.maxHandshakeRounds;
-    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : 3;
-  } catch { return 3; }
+const CLASSIFICATION_TARGET: Record<ReworkClassification, ReworkTarget> = {
+  'scope-or-requirement': 'analysis', design: 'plan', implementation: 'code',
+  'human-decision': 'pause', 'insufficient-evidence': 'pause'
+};
+
+function semanticDigest(value: string): string {
+  return createHash('sha256').update(value.normalize('NFKC').replace(/\s+/g, ' ').trim()).digest('hex');
+}
+
+function normalizedTaskFact(value: string): string {
+  return value.normalize('NFKC').replace(/\s+/g, ' ').trim();
+}
+
+function semanticFindingEvidence(reviewContent: string, heading: ReturnType<typeof scanVisibleMarkdown>['headings'][number], end: number): string {
+  const title = heading.text.replace(/^\d+[.、：:]\s*/, '').trim();
+  return `${title}\n${reviewContent.slice(heading.end, end)}`;
+}
+
+function findingEvidence(reviewContent: string, evidence: string): string | null {
+  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: string, content: string): string {
+  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: readonly LedgerRow[], stage: ReviewStage): string {
@@ -103,8 +148,7 @@ function mapWrite(intent: LedgerIntent, entityId: string, before: LedgerRow | nu
 function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {}): LedgerIntentResult {
   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) return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+  if (resolved.state !== 'active') return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   let content: string;
   let rows: LedgerRow[];
   try {
@@ -123,11 +167,14 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
   }
 
   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);
@@ -137,12 +184,34 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
       if (actualHash !== intent.sourceSha256) return failed(intent, 'LEDGER_IDENTITY_CONFLICT', 'rework intent source artifact hash does not match', resolved.taskId, intent.intentId);
       const parsed = parseReworkIntentDocument(content);
       if (!parsed.ok) return failed(intent, parsed.code, parsed.message, resolved.taskId, intent.intentId);
-      const nextIntent: ReworkIntent = {
+      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: ReworkIntent = {
         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: ReworkClassification = same ? 'insufficient-evidence' : intent.classification;
+      const nextIntent: ReworkIntent = {
+        ...requestedIntent, target: CLASSIFICATION_TARGET[classification], classification
+      };
+      const now = nextIntent.declaredAt;
+      const superseded = parsed.intents.map((candidate) => candidate.status === 'pending'
+        ? { ...candidate, status: 'superseded' as const, 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 } });
       if (result.status === 'failed') return failed(intent, result.error.code, result.error.message, result.taskId, intent.intentId);
@@ -152,6 +221,75 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
     }
   }
 
+  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' as const, consumedAt: now } : row);
+    let entityId: string | null = 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: LedgerRow | null = null;
   let after: LedgerRow;
   if (intent.kind === 'finding-upsert') {
@@ -213,8 +351,7 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
             ? new Set(['confirmed', 'open', 'needs-human-decision'])
             : before.status === 'cannot-judge' ? new Set(['open', 'needs-human-decision']) : new Set<string>();
         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 };
@@ -248,7 +385,7 @@ function applyLedgerIntent(intent: LedgerIntent, options: TaskWriteOptions = {})
   }
 
   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/lib/task/lifecycle-path.ts

@@ -0,0 +1,98 @@
+import { createHash } from 'node:crypto';
+
+import { extractSection } from './sections.ts';
+
+const PATH_STAGES = {
+  streamlined: ['analysis', 'code', 'review-code'],
+  standard: ['analysis', 'plan', 'code', 'review-code'],
+  full: ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']
+} as const;
+
+type LifecyclePath = keyof typeof PATH_STAGES;
+type LifecycleStage = (typeof PATH_STAGES)[LifecyclePath][number];
+type LifecyclePathDecision = Readonly<{
+  path: LifecyclePath;
+  stages: readonly LifecycleStage[];
+  basis: string;
+  unmetHigherConditions: string;
+  upgradeTriggers: string;
+  semanticDigest: string;
+  sourceArtifact: string;
+  sourceSha256: string;
+}>;
+type LifecyclePathState =
+  | Readonly<{ status: 'missing'; decision: null; message: string }>
+  | Readonly<{ status: 'invalid'; decision: null; message: string }>
+  | Readonly<{ status: 'valid'; decision: LifecyclePathDecision; message: null }>;
+
+const FIELD_ALIASES = {
+  path: ['本任务路径', 'Path'],
+  basis: ['判定依据', 'Basis'],
+  unmetHigherConditions: ['未满足的更高路径条件', '未满足的较低路径条件', 'Unmet Higher-path Conditions'],
+  upgradeTriggers: ['升级触发条件', 'Upgrade Triggers']
+} as const;
+
+function normalizeText(value: string): string {
+  return value.normalize('NFKC').replace(/\s+/g, ' ').trim().replace(/[。.]$/, '');
+}
+
+function digest(value: unknown): string {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+
+function pathToken(value: string): LifecyclePath | null {
+  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: string, aliases: readonly string[]): string[] {
+  const wanted = new Set(aliases);
+  const values: string[] = [];
+  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: string,
+  sourceArtifact = '',
+  sourceSha256 = ''
+): LifecyclePathState {
+  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)])) as Record<keyof typeof FIELD_ALIASES, string[]>;
+  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: LifecyclePathState | undefined, stage: LifecycleStage): boolean {
+  return state?.status === 'valid' && state.decision.stages.includes(stage);
+}
+
+export { PATH_STAGES, parseLifecyclePathDecision, pathIncludes };
+export type { LifecyclePath, LifecyclePathDecision, LifecyclePathState, LifecycleStage };