@fitlab-ai/agent-infra 0.11.3 → 0.11.4

package/lib/task/capabilities.ts

@@ -4,16 +4,19 @@ import path from 'node:path';
 import { parseArtifactName } from './artifact-name.ts';
 import type { InvalidationDocument } from './invalidation.ts';
 import { invalidationBlocks, isArtifactInvalidated, parseInvalidationDocument } from './invalidation.ts';
-import { receiptForOutput } from './artifact-receipts.ts';
+import { parseArtifactReceipts, receiptForOutput } from './artifact-receipts.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.ts';
 import { parseReworkIntentDocument } from './rework-intent.ts';
-import type { ReworkIntent } from './rework-intent.ts';
+import type { ReworkIntent, ReworkTarget } from './rework-intent.ts';
 import { sha256File } from './artifact-receipts.ts';
 import { hasOpenLifecycleExecution } from './activity-log.ts';
 import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.ts';
 import type { QualificationAudit, TaskQualification } from './qualification-audit.ts';
+import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.ts';
+import type { LifecyclePathState } from './lifecycle-path.ts';
+import { parseImplementationInputs } from './implementation-inputs.ts';
 
 const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code']);
 
@@ -49,6 +52,9 @@ type LifecycleFacts = {
   recommendedAction?: LifecycleAction | null;
   qualificationStale?: boolean;
   qualificationStaleArtifacts?: readonly string[];
+  pathState?: LifecyclePathState;
+  reworkClassificationRequired?: readonly ('analysis' | 'plan' | 'code')[];
+  resolvedHumanDecisions?: Partial<Record<'analysis' | 'plan' | 'code', 'review' | 'implementation'>>;
 };
 type CapabilityResult = {
   allowed: boolean;
@@ -80,6 +86,11 @@ function hasArtifact(facts: LifecycleFacts, action: LifecycleAction): boolean {
   return (facts.artifacts[action]?.length ?? 0) > 0;
 }
 
+function effectiveReworkTarget(target: ReworkTarget, pathState: LifecyclePathState | undefined): ReworkTarget {
+  if (target === 'plan' && pathState?.status === 'valid' && !pathIncludes(pathState, 'plan')) return 'analysis';
+  return target;
+}
+
 function canStart(action: LifecycleAction, facts: LifecycleFacts, trigger: ExplicitTrigger): CapabilityResult {
   if (!trigger || trigger.requestedAction !== action) return deny('TRIGGER_ACTION_MISMATCH', `requested=${trigger?.requestedAction ?? 'missing'}`);
   if (!trigger.requestId || !trigger.requestId.trim()) return deny('TRIGGER_REQUEST_ID_REQUIRED');
@@ -93,11 +104,32 @@ function canStart(action: LifecycleAction, facts: LifecycleFacts, trigger: Expli
   }
   if (facts.taskState !== 'active') return deny('TASK_NOT_ACTIVE', `state=${facts.taskState}`);
   if (invalidationBlocks(facts.invalidation)) return deny('INVALIDATION_INCOMPLETE');
-  if (facts.qualificationStale && facts.recommendedAction !== action) {
-    return deny('QUALIFICATION_STALE', ...(facts.qualificationStaleArtifacts ?? ['qualification audit is stale']));
-  }
   if (facts.executionBusy) return deny('EXECUTION_BUSY');
 
+  const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
+  if (pendingIntent) {
+    const target = effectiveReworkTarget(pendingIntent.target, facts.pathState);
+    const requirementRestart = action === 'analysis' && trigger.reasonCode === 'new-requirement';
+    if (!requirementRestart && (target === 'pause' || target !== action)) {
+      return deny(target === 'pause' ? 'REWORK_PAUSED' : 'REWORK_INTENT_TARGET_MISMATCH', pendingIntent.intentId);
+    }
+  }
+
+  if (facts.pathState && facts.pathState.status !== 'valid') {
+    return action === 'analysis'
+      ? allow(`lifecycle-path-${facts.pathState.status}`)
+      : deny('LIFECYCLE_PATH_INVALID', facts.pathState.message);
+  }
+  if (facts.pathState?.status === 'valid'
+    && ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code'].includes(action)
+    && !pathIncludes(facts.pathState, action as never)) {
+    return deny('ARTIFACT_STAGE_NOT_SELECTED', `path=${facts.pathState.decision.path}`, `stage=${action}`);
+  }
+  if (facts.reworkClassificationRequired?.includes(action as 'analysis' | 'plan' | 'code')
+    && !(facts.reworkIntents ?? []).some((intent) => intent.status === 'pending')) {
+    return deny('REWORK_CLASSIFICATION_REQUIRED', `stage=${action}`);
+  }
+
   const implicit = trigger.explicitRequest === false;
   if (action === 'analysis') {
     if (!implicit || hasArtifact(facts, 'analysis') || facts.recommendedAction === 'analysis') return allow('analysis-capability');
@@ -107,6 +139,9 @@ function canStart(action: LifecycleAction, facts: LifecycleFacts, trigger: Expli
     return hasArtifact(facts, 'analysis') ? allow('analysis-artifact') : deny('ANALYSIS_ARTIFACT_REQUIRED');
   }
   if (action === 'plan') {
+    if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'standard') {
+      return hasArtifact(facts, 'analysis') ? allow('analysis-artifact') : deny('ANALYSIS_ARTIFACT_REQUIRED');
+    }
     if (!hasArtifact(facts, 'review-analysis')) return deny('ANALYSIS_REVIEW_REQUIRED');
     if (!reviewMatchesLatest(facts, 'analysis', 'review-analysis')) return deny('ANALYSIS_REVIEW_NOT_LATEST');
     if (facts.reviews['review-analysis'] !== 'approved') return deny('ANALYSIS_REVIEW_NOT_APPROVED');
@@ -118,11 +153,22 @@ function canStart(action: LifecycleAction, facts: LifecycleFacts, trigger: Expli
   }
   if (action === 'code') {
     if (trigger.implementationInput) {
+      if (facts.resolvedHumanDecisions?.code === 'implementation') return allow('human-decision-implementation-input');
       if (!hasArtifact(facts, 'review-code')) return deny('CODE_REVIEW_REQUIRED');
       if (!reviewMatchesLatest(facts, 'code', 'review-code')) return deny('CODE_REVIEW_NOT_LATEST');
       if (facts.reviews['review-code'] !== 'approved') return deny('CODE_REVIEW_NOT_APPROVED');
       return allow('implementation-input');
     }
+    if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'streamlined') {
+      if (!hasArtifact(facts, 'analysis')) return deny('ANALYSIS_ARTIFACT_REQUIRED');
+      if (facts.unresolvedLedger.analysis > 0) return deny('ANALYSIS_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.analysis}`);
+      return allow('analysis-path-approved');
+    }
+    if (facts.pathState?.status === 'valid' && facts.pathState.decision.path === 'standard') {
+      if (!hasArtifact(facts, 'plan')) return deny('PLAN_ARTIFACT_REQUIRED');
+      if (facts.unresolvedLedger.plan > 0) return deny('PLAN_LEDGER_BLOCKED', `unresolved=${facts.unresolvedLedger.plan}`);
+      return allow('plan-path-approved');
+    }
     if (!hasArtifact(facts, 'review-plan')) return deny('PLAN_REVIEW_REQUIRED');
     if (!reviewMatchesLatest(facts, 'plan', 'review-plan')) return deny('PLAN_REVIEW_NOT_LATEST');
     if (facts.reviews['review-plan'] !== 'approved') return deny('PLAN_REVIEW_NOT_APPROVED');
@@ -147,14 +193,6 @@ function latestArtifact(names: readonly string[]): string | null {
     .sort((left, right) => right.round - left.round || left.name.localeCompare(right.name))[0]?.name ?? null;
 }
 
-function reviewedInputName(content: string, expectedFamily: 'analysis' | 'plan' | 'code'): string | null {
-  const header = content.split(/\r?\n/).findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
-  if (header < 0) return null;
-  const referenceBlock = content.split(/\r?\n/).slice(header, header + 12).join('\n');
-  const expected = new RegExp('`' + expectedFamily + '(?:-r[2-9]|-r[1-9]\\d+)?\\.md`');
-  return expected.exec(referenceBlock)?.[0].slice(1, -1) ?? null;
-}
-
 function reviewMatchesLatest(facts: LifecycleFacts, source: 'analysis' | 'plan' | 'code', review: 'review-analysis' | 'review-plan' | 'review-code'): boolean {
   const latestSource = latestArtifact(facts.artifacts[source] ?? []);
   return Boolean(latestSource && facts.reviewedInputs?.[review] === latestSource);
@@ -172,31 +210,53 @@ function qualificationCandidateSnapshotMatches(
   });
 }
 
-const QUALIFICATION_RECOVERY_ORDER: ReadonlyArray<{ action: LifecycleAction; pattern: RegExp }> = [
-  { action: 'analysis', pattern: /^analysis(?:-r\d+)?\.md$/ },
-  { action: 'review-analysis', pattern: /^review-analysis(?:-r\d+)?\.md$/ },
-  { action: 'plan', pattern: /^plan(?:-r\d+)?\.md$/ },
-  { action: 'review-plan', pattern: /^review-plan(?:-r\d+)?\.md$/ },
-  { action: 'code', pattern: /^code(?:-r\d+)?\.md$/ },
-  { action: 'review-code', pattern: /^review-code(?:-r\d+)?\.md$/ }
-];
-
-function qualificationRecoveryAction(facts: LifecycleFacts): LifecycleAction | null {
-  const stale = facts.qualificationStaleArtifacts ?? [];
-  return QUALIFICATION_RECOVERY_ORDER.find(({ pattern }) => stale.some((name) => pattern.test(name)))?.action ?? null;
-}
-
 function recommendNext(facts: LifecycleFacts): LifecycleRecommendation {
-  if (facts.qualificationStale) {
-    const action = qualificationRecoveryAction(facts);
-    return {
-      action,
-      reasonCode: 'QUALIFICATION_RECOVERY_REQUIRED',
-      evidence: facts.qualificationStaleArtifacts ?? ['qualification audit is stale']
-    };
+  if ((facts.reworkClassificationRequired?.length ?? 0) > 0
+    && !(facts.reworkIntents ?? []).some((intent) => intent.status === 'pending')) {
+    return { action: null, reasonCode: 'REWORK_CLASSIFICATION_REQUIRED', evidence: facts.reworkClassificationRequired ?? [] };
   }
   const pendingIntent = (facts.reworkIntents ?? []).find((intent) => intent.status === 'pending');
-  if (pendingIntent) return { action: pendingIntent.target, reasonCode: 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
+  if (pendingIntent) {
+    const target = effectiveReworkTarget(pendingIntent.target, facts.pathState);
+    return { action: target === 'pause' ? null : target, reasonCode: target === 'pause' ? 'REWORK_PAUSED' : 'REWORK_INTENT_PENDING', evidence: [pendingIntent.intentId, pendingIntent.findingId] };
+  }
+  if (facts.pathState && facts.pathState.status !== 'valid') {
+    return { action: 'analysis', reasonCode: facts.pathState.status === 'missing' ? 'LIFECYCLE_PATH_MISSING' : 'LIFECYCLE_PATH_INVALID', evidence: [facts.pathState.message] };
+  }
+  if (facts.pathState?.status === 'valid') {
+    for (const stage of facts.pathState.decision.stages) {
+      if (stage === 'analysis' && !hasArtifact(facts, stage)) return { action: stage, reasonCode: 'ANALYSIS_ARTIFACT_MISSING', evidence: ['analysis artifact is absent'] };
+      if (stage === 'review-analysis' && (!reviewMatchesLatest(facts, 'analysis', stage) || facts.reviews[stage] !== 'approved')) {
+        if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.analysis === 'review') {
+          return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['analysis decision was resolved'] };
+        }
+        return facts.reviews[stage] === 'changes-requested'
+          ? { action: 'analysis', reasonCode: 'ANALYSIS_REWORK_REQUIRED', evidence: ['analysis review is not approved'] }
+          : { action: stage, reasonCode: 'ANALYSIS_REVIEW_MISSING', evidence: ['analysis review does not bind the latest analysis artifact'] };
+      }
+      if (stage === 'plan' && !hasArtifact(facts, stage)) return { action: stage, reasonCode: 'PLAN_ARTIFACT_MISSING', evidence: ['plan artifact is absent'] };
+      if (stage === 'review-plan' && (!reviewMatchesLatest(facts, 'plan', stage) || facts.reviews[stage] !== 'approved')) {
+        if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.plan === 'review') {
+          return { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['plan decision was resolved'] };
+        }
+        return facts.reviews[stage] === 'changes-requested'
+          ? { action: 'plan', reasonCode: 'PLAN_REWORK_REQUIRED', evidence: ['plan review is not approved'] }
+          : { action: stage, reasonCode: 'PLAN_REVIEW_MISSING', evidence: ['plan review does not bind the latest plan artifact'] };
+      }
+      if (stage === 'code' && !hasArtifact(facts, stage)) return { action: stage, reasonCode: 'CODE_ARTIFACT_MISSING', evidence: ['code artifact is absent'] };
+      if (stage === 'review-code' && (!reviewMatchesLatest(facts, 'code', stage) || facts.reviews[stage] !== 'approved')) {
+        if (facts.reviews[stage] === 'changes-requested' && facts.resolvedHumanDecisions?.code) {
+          return facts.resolvedHumanDecisions.code === 'implementation'
+            ? { action: 'code', reasonCode: 'HUMAN_DECISION_IMPLEMENTATION_REQUIRED', evidence: ['code decision requires implementation'] }
+            : { action: stage, reasonCode: 'HUMAN_DECISION_REVIEW_REQUIRED', evidence: ['code decision requires no implementation'] };
+        }
+        return facts.reviews[stage] === 'changes-requested'
+          ? { action: 'code', reasonCode: 'CODE_REWORK_REQUIRED', evidence: ['code review is not approved'] }
+          : { action: stage, reasonCode: 'CODE_REVIEW_MISSING', evidence: ['code review does not bind the latest code artifact'] };
+      }
+    }
+    return { action: null, reasonCode: 'LIFECYCLE_REVIEWED', evidence: ['selected lifecycle path is complete'] };
+  }
   if (!hasArtifact(facts, 'analysis')) return { action: 'analysis', reasonCode: 'ANALYSIS_ARTIFACT_MISSING', evidence: ['analysis artifact is absent'] };
   if (!hasArtifact(facts, 'review-analysis') || !reviewMatchesLatest(facts, 'analysis', 'review-analysis')) {
     return { action: 'review-analysis', reasonCode: 'ANALYSIS_REVIEW_MISSING', evidence: ['analysis review does not bind the latest analysis artifact'] };
@@ -247,8 +307,10 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       const family = familyFor(name);
       return !family || !isArtifactInvalidated(invalidation.document, family, name);
     });
+    const allArtifactHashes: Record<string, string> = {};
+    for (const name of files) allArtifactHashes[name] = sha256File(path.join(taskDir, name));
     const artifactHashes: Record<string, string> = {};
-    for (const name of activeFiles) artifactHashes[name] = sha256File(path.join(taskDir, name));
+    for (const name of activeFiles) artifactHashes[name] = allArtifactHashes[name]!;
     const artifacts: Partial<Record<LifecycleAction, readonly string[]>> = Object.fromEntries(
       artifactFamilies.map((family) => [
         family, activeFiles.filter((name) => familyFor(name) === family)
@@ -288,18 +350,67 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       if (!latest) continue;
       const reviewContent = fs.readFileSync(path.join(taskDir, latest), 'utf8');
       const expectedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
-      const input = reviewedInputName(reviewContent, expectedFamily);
-      const receipt = input ? receiptForOutput(content, latest) : null;
-      if (input && receipt?.input === input && artifactHashes[input] === receipt.inputSha256) reviewedInputs[family] = input;
+      const receipt = receiptForOutput(content, latest);
+      const input = receipt?.input;
+      if (
+        input
+        && parseArtifactName(input)?.family === expectedFamily
+        && (artifacts[expectedFamily] ?? []).includes(input)
+        && artifactHashes[input] === receipt.inputSha256
+      ) reviewedInputs[family] = input;
       const parsed = parseReviewSummary(reviewContent);
       if (!parsed.ok) continue;
       const verdict = resolveCanonicalVerdict(parsed.summary);
       if (verdict.ok) reviews[family] = verdict.verdict === 'Approved' ? 'approved' : verdict.verdict === 'Changes Requested' ? 'changes-requested' : 'rejected';
     }
+    const reworkClassificationRequired: Array<'analysis' | 'plan' | 'code'> = [];
+    const receipts = parseArtifactReceipts(content).rows;
+    for (const [reviewFamily, stage] of [['review-analysis', 'analysis'], ['review-plan', 'plan'], ['review-code', 'code']] as const) {
+      const cycles = receipts.filter((receipt) => receipt.event === `${reviewFamily}.completed` && files.includes(receipt.output)
+        && allArtifactHashes[receipt.input] === receipt.inputSha256).map((receipt) => {
+        const parsed = parseReviewSummary(fs.readFileSync(path.join(taskDir, receipt.output), 'utf8'));
+        const verdict = parsed.ok ? resolveCanonicalVerdict(parsed.summary) : null;
+        return {
+          input: receipt.input,
+          output: receipt.output,
+          outputRound: parseArtifactName(receipt.output)?.round ?? 0,
+          inputRound: parseArtifactName(receipt.input)?.round ?? 0,
+          verdict: verdict?.ok ? verdict.verdict : null
+        };
+      }).sort((left, right) => left.inputRound - right.inputRound || left.outputRound - right.outputRound || left.output.localeCompare(right.output));
+      const latest = cycles.at(-1);
+      const trailingInputRounds = new Set<number>();
+      for (let index = cycles.length - 1; index >= 0 && cycles[index]!.verdict === 'Changes Requested'; index -= 1) {
+        trailingInputRounds.add(cycles[index]!.inputRound);
+      }
+      const handled = latest && (rework.intents ?? []).some((intent) => intent.sourceArtifact === latest.output
+        && intent.sourceSha256 === allArtifactHashes[latest.output]);
+      const latestActiveReview = latestArtifact(artifacts[reviewFamily] ?? []);
+      const latestActiveInput = latestArtifact(artifacts[stage] ?? []);
+      const latestCycleIsActive = latest?.output === latestActiveReview && latest.input === latestActiveInput;
+      if (latestCycleIsActive && latest.verdict === 'Changes Requested' && trailingInputRounds.size >= 2 && !handled) reworkClassificationRequired.push(stage);
+    }
     const unresolvedLedger = { analysis: 0, plan: 0, code: 0 };
     if (ledger.present) {
       for (const stage of ['analysis', 'plan', 'code'] as const) unresolvedLedger[stage] = summarizeLedgerStage(ledger.rows, stage).unresolved.length;
     }
+    const latestAnalysis = latestArtifact(artifacts.analysis ?? []);
+    const pathState = latestAnalysis
+      ? parseLifecyclePathDecision(fs.readFileSync(path.join(taskDir, latestAnalysis), 'utf8'), latestAnalysis, artifactHashes[latestAnalysis] ?? '')
+      : { status: 'missing' as const, decision: null, message: 'analysis artifact is missing' };
+    const resolvedHumanDecisions: NonNullable<LifecycleFacts['resolvedHumanDecisions']> = {};
+    const implementationInputs = parseImplementationInputs(content).rows;
+    for (const stage of ['analysis', 'plan', 'code'] as const) {
+      const reviewFamily = `review-${stage}` as 'review-analysis' | 'review-plan' | 'review-code';
+      const latestReview = latestArtifact(artifacts[reviewFamily] ?? []);
+      if (!latestReview || reviews[reviewFamily] !== 'changes-requested') continue;
+      const latestHash = artifactHashes[latestReview];
+      const decision = rework.intents.find((intent) => intent.status === 'consumed'
+        && intent.classification === 'human-decision' && intent.sourceArtifact === latestReview && intent.sourceSha256 === latestHash);
+      if (!decision) continue;
+      const implementationInput = implementationInputs.find((input) => input.ledgerId === decision.findingId);
+      resolvedHumanDecisions[stage] = stage === 'code' && implementationInput?.status === 'pending' ? 'implementation' : 'review';
+    }
     const facts: LifecycleFacts = {
       taskState, currentStep: String(metadata.current_step ?? ''), artifacts, reviews,
       staleArtifacts, reviewedInputs, artifactHashes,
@@ -309,6 +420,9 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       recommendedAction: null,
       qualificationStale: qualificationStaleArtifacts.length > 0,
       qualificationStaleArtifacts
+      , pathState
+      , reworkClassificationRequired
+      , resolvedHumanDecisions
     };
     facts.recommendedAction = recommendNext(facts).action;
     return { ok: true, facts };
@@ -317,5 +431,5 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
   }
 }
 
-export { buildLifecycleFacts, canStart, recommendNext };
+export { buildLifecycleFacts, canStart, effectiveReworkTarget, recommendNext };
 export type { CapabilityResult, ExplicitTrigger, LifecycleAction, LifecycleFacts, LifecycleFactsResult, LifecycleRecommendation, TriggerInitiator, TriggerReason };

package/lib/task/commands/status.ts

@@ -386,6 +386,8 @@ type StatusModel = {
   orchestration: OrchestrationInfo;
   invalidation?: { status: string; processed: number; total: number; pendingIntents: number };
   recommendation?: string;
+  recommendationReason?: string;
+  lifecyclePath?: string;
   git: GitInfo;
 };
 
@@ -444,7 +446,11 @@ function renderStatus(model: StatusModel): string[] {
     ])
   );
 
-  lines.push('', 'Recommendation', ...renderPairs([['action', model.recommendation ?? DASH]]));
+  lines.push('', 'Recommendation', ...renderPairs([
+    ['path', model.lifecyclePath ?? DASH],
+    ['action', model.recommendation ?? DASH],
+    ['reason', model.recommendationReason ?? DASH]
+  ]));
 
   lines.push(
     '',
@@ -546,7 +552,8 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
         pendingIntents
       };
   const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
-  const recommendation = facts.ok ? (recommendNext(facts.facts).action ?? DASH) : DASH;
+  const next = facts.ok ? recommendNext(facts.facts) : null;
+  const recommendation = next?.action ?? DASH;
 
   return {
     taskId: input.taskId,
@@ -560,6 +567,8 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
     orchestration: collectOrchestration(input.taskDir),
     invalidation: invalidationInfo,
     recommendation,
+    recommendationReason: next?.reasonCode ?? 'TASK_CAPABILITY_FACTS_INVALID',
+    lifecyclePath: facts.ok && facts.facts.pathState?.status === 'valid' ? facts.facts.pathState.decision.path : facts.ok ? facts.facts.pathState?.status ?? DASH : DASH,
     git: collectGit(fm.branch ?? '', run)
   };
 }

package/lib/task/control-authority.ts

@@ -26,6 +26,7 @@ import {
 import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 import {
   applyTaskFinalization,
+  commitPreparedTaskFinalization,
   type TaskFinalizationRequest,
   type TaskFinalizationResult
 } from './finalization.ts';
@@ -860,7 +861,8 @@ export function dispatchTaskControlOperation(
   }
   if (operation.family === 'task-finalization') {
     operationTaskId(context, operation.request.taskRef);
-    return applyTaskFinalization(operation.request, {
+    const finalize = context.source === 'sandbox-executor' ? commitPreparedTaskFinalization : applyTaskFinalization;
+    return finalize(operation.request, {
       repoRoot: context.repoRoot,
       ...(context.source === 'sandbox-executor' ? {
         controlBinding: { generation: context.generation, requestId: context.requestId }

package/lib/task/decision-intents.ts

@@ -17,6 +17,7 @@ import { extractSection, extractSubSection, findSectionHeading } from './section
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
 import { allowsManualOverride } from './guard-override.ts';
+import { consumeHumanDecisionReworkIntents, parseReworkIntentDocument, reworkIntentMutation } from './rework-intent.ts';
 
 type HumanDecisionRequest = {
   taskRef?: string;
@@ -177,6 +178,14 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
     body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
   });
+  try {
+    const parsedRework = parseReworkIntentDocument(content);
+    if (!parsedRework.ok) return failed('DECISION_DOCUMENT_INVALID', parsedRework.message, resolved.taskId, row.id);
+    const consumed = consumeHumanDecisionReworkIntents(parsedRework.intents, row.id, metadata.timestamp);
+    if (consumed.changed) mutations.push(reworkIntentMutation(content, consumed.intents));
+  } catch (error) {
+    return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
+  }
   const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
     ...options,
     taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },

package/lib/task/delivery.ts

@@ -4,8 +4,7 @@ import path from 'node:path';
 
 import { parseTaskFrontmatter } from './frontmatter.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead, validateBaseRef, validateRemote } from './delivery-target.ts';
-import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead, findAuthoritativeReviewCodeArtifact } from './review-fingerprint.ts';
+import { resolveDeliveryTarget, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import { withRepositoryMutationLock, withTaskExecutionLock } from './task-execution-lock.ts';
 
@@ -47,40 +46,6 @@ function validateBranch(cwd: string, branch: string): boolean {
   return git(cwd, ['check-ref-format', `refs/heads/${branch}`]).status === 0;
 }
 
-function validateReviewTargetCompatibility(
-  repoRoot: string,
-  taskDir: string,
-  target: { remote: string; baseRef: string },
-  reviewedHead: string
-): { ok: true } | { ok: false; code: string; message: string } {
-  const artifact = findAuthoritativeReviewCodeArtifact(taskDir);
-  if (!artifact.ok || !artifact.path) return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'A current review-code artifact is required before delivery' };
-  let content: string;
-  try { content = fs.readFileSync(artifact.path, 'utf8'); }
-  catch (error) { return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: error instanceof Error ? error.message : String(error) }; }
-  const savedReviewedHead = extractReviewedHead(content) || extractReviewBaseline(content);
-  const savedTargetHead = extractReviewTargetHead(content);
-  const savedDiffBase = extractReviewDiffBase(content);
-  if (!savedReviewedHead || !savedTargetHead || !savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: 'review-code must save reviewed head, target head, and diff base before delivery' };
-  }
-  if (savedReviewedHead !== reviewedHead) {
-    return { ok: false, code: 'DELIVERY_REVIEW_REQUIRED', message: 'review-code reviewed head does not match last_reviewed_commit' };
-  }
-  const saved = resolveDiffBase(repoRoot, reviewedHead, savedTargetHead);
-  if (!saved.ok || saved.diffBase !== savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_INVALID', message: saved.ok ? 'saved review diff base does not match saved target head' : saved.message };
-  }
-  const currentTarget = resolveTargetHead(repoRoot, target);
-  if (!currentTarget.ok) return { ok: false, code: currentTarget.code, message: currentTarget.message };
-  const current = resolveDiffBase(repoRoot, reviewedHead, currentTarget.head!);
-  if (!current.ok) return { ok: false, code: current.code, message: current.message };
-  if (current.diffBase !== savedDiffBase) {
-    return { ok: false, code: 'DELIVERY_REVIEW_TARGET_CHANGED', message: 'current delivery target changed the reviewed diff base; re-run review-code' };
-  }
-  return { ok: true };
-}
-
 function failure(taskId: string | null, code: string, message: string, retryable = false, status: 'failed' | 'blocked' = retryable ? 'blocked' : 'failed'): TaskBranchDeliveryResult {
   return { status, changed: false, taskId, remoteHead: null, localHead: null, state: null, error: { code, message, retryable } };
 }
@@ -115,10 +80,6 @@ function deliverUnlocked(
   const status = git(repoRoot, ['status', '--porcelain=v1']);
   if (status.status !== 0) return failure(taskId, 'DELIVERY_GIT_INSPECT_FAILED', status.stderr.trim() || 'Unable to inspect Git state');
   if (status.stdout.trim()) return failure(taskId, 'DELIVERY_WORKTREE_DIRTY', 'Working tree must be clean before branch delivery');
-  const reviewed = frontmatter.last_reviewed_commit ?? '';
-  if (reviewed !== localHead) return failure(taskId, 'DELIVERY_REVIEW_REQUIRED', 'Local HEAD must equal last_reviewed_commit before delivery');
-  const reviewTarget = validateReviewTargetCompatibility(repoRoot, taskDir, target.value, reviewed);
-  if (!reviewTarget.ok) return failure(taskId, reviewTarget.code, reviewTarget.message, reviewTarget.code.includes('UNAVAILABLE'), reviewTarget.code.includes('UNAVAILABLE') ? 'blocked' : 'failed');
   const ref = `refs/heads/${branch}`;
   const remoteOutput = git(repoRoot, ['ls-remote', '--refs', target.value.remote, ref]);
   if (remoteOutput.status !== 0) return failure(taskId, 'DELIVERY_REMOTE_UNAVAILABLE', remoteOutput.stderr.trim() || 'Unable to inspect the delivery remote', true);