@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/lib/task/lifecycle.ts

@@ -107,13 +107,11 @@ type TaskLifecycleOptions = {
   fileSystem?: Partial<LifecycleFileSystem>;
   taskFileSystem?: Partial<TaskFileSystem>;
   directoryRenameSync?: (source: string, target: string) => void;
-  manualOverride?: Readonly<{ failureId: string; operator: string; reason: string }>;
+  /** Write the terminal task document and durable journal, but leave the move
+   * and short-id mutation for a separately authorized commit. */
+  prepareOnly?: boolean;
 };
 
-function allowsManualOverride(options: TaskLifecycleOptions, code: string): boolean {
-  return options.manualOverride?.failureId === `lifecycle.apply:${code}`;
-}
-
 const STEPS: readonly LifecycleStep[] = ['task-written', 'directory-moved', 'registry-committed'];
 const DEFAULT_IO: LifecycleFileSystem = {
   renameSync: (source, target) => fs.renameSync(source, target),
@@ -359,6 +357,44 @@ export function readLifecycleJournalEvidence(repoRoot: string, taskId: string):
   } catch { return { exists: true, completedSteps: [], failure: 'SANDBOX_CONTROL_LIFECYCLE_JOURNAL_INVALID' }; }
 }
 
+export function inspectTaskLifecycleProgress(
+  repoRoot: string, taskId: string, agent: string
+): 'not-started' | 'started-recoverable' | 'unknown' {
+  try {
+    const hot = locateHotTaskDirs(repoRoot, taskId);
+    if (hot.length !== 1 || (hot[0]!.state !== 'active' && hot[0]!.state !== 'completed')) return 'unknown';
+    const { state, taskDir } = hot[0]!;
+    const content = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    const frontmatter = parseTypedTaskFrontmatter(content);
+    if (frontmatter.id !== taskId) return 'unknown';
+    const journalPath = path.join(taskDir, '.task-lifecycle.json');
+    if (!fs.existsSync(journalPath)) {
+      if (state === 'active') return frontmatter.status === 'active' ? 'not-started' : 'unknown';
+      return matchingCompletion(content, { taskRef: taskId, intent: 'complete', agent })
+        ? 'started-recoverable' : 'unknown';
+    }
+    const journal = parseJournal(fs.readFileSync(journalPath, 'utf8'));
+    const request: TaskLifecycleRequest = { taskRef: taskId, intent: 'complete', agent };
+    if (journal.taskId !== taskId || journal.intent !== 'complete'
+      || journal.intentDigest !== intentIdentity(request, taskId)
+      || journal.sourceState !== 'active' || journal.targetState !== 'completed') return 'unknown';
+    if (journal.completedSteps.some((step, index) => STEPS[index] !== step)) return 'unknown';
+    const directoryMoved = journal.completedSteps.includes('directory-moved');
+    const registryCommitted = journal.completedSteps.includes('registry-committed');
+    const hasShortId = loadShortIdByTaskId(repoRoot).has(taskId);
+    if (state === 'active' && (directoryMoved || !hasShortId)) return 'unknown';
+    if (state === 'completed' && (!journal.completedSteps.includes('task-written')
+      || !matchingCompletion(content, request) || (registryCommitted && hasShortId))) return 'unknown';
+    if (frontmatter.status !== state
+      && !(state === 'active' && frontmatter.status === 'completed' && matchingCompletion(content, request))) {
+      return 'unknown';
+    }
+    return 'started-recoverable';
+  } catch {
+    return 'unknown';
+  }
+}
+
 type DirectoryEntry = Readonly<{ relativePath: string; kind: 'file' | 'directory'; size: number; digest: string }>;
 
 function directoryManifest(root: string): DirectoryEntry[] {
@@ -465,7 +501,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     }
     return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: `task ${taskId} is already ${spec.target} with a different lifecycle intent` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   }
-  if (!spec.sources.includes(sourceState) && !existingJournal && !allowsManualOverride(options, 'LIFECYCLE_SOURCE_INVALID')) {
+  if (!spec.sources.includes(sourceState) && !existingJournal) {
     return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   }
   if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal) {
@@ -476,7 +512,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   try { frontmatter = parseTypedTaskFrontmatter(content); }
   catch (error) { return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: error instanceof Error ? error.message : String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath }); }
   if (frontmatter.id !== taskId) return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
-  if (!locateActivityLog(content) && !allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING')) return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
+  if (!locateActivityLog(content)) return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   if (spec.target === 'active') {
     const contract = validateCurrentTaskContract(content);
     if (!contract.ok) return failed(request, { code: 'LIFECYCLE_DOCUMENT_INVALID', message: contract.message }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
@@ -490,10 +526,10 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   }
   const registry = JSON.parse(registryRequest.output || '{"version":1,"ids":{}}') as { ids: Record<string, string> };
   const registeredKey = Object.entries(registry.ids).find(([, candidate]) => candidate === taskId)?.[0];
-  if (spec.registry === 'release' && sourceState === 'active' && !registeredKey && !allowsManualOverride(options, 'LIFECYCLE_SHORT_ID_PRECONDITION')) {
+  if (spec.registry === 'release' && sourceState === 'active' && !registeredKey) {
     return failed(request, { code: 'LIFECYCLE_SHORT_ID_PRECONDITION', message: 'active source has no short-id registry entry' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   }
-  if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1 && !allowsManualOverride(options, 'SHORT_ID_CAPACITY_EXCEEDED')) {
+  if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1) {
     return failed(request, { code: 'SHORT_ID_CAPACITY_EXCEEDED', message: 'short-id registry has no free slot' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
   }
   const digest = intentIdentity(request, taskId);
@@ -511,8 +547,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
       if (!journal.failure) return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
       return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: STEPS.filter((step) => !journal.completedSteps.includes(step)) });
     }
-    const overrideResumesRecordedFailure = journal.failure && allowsManualOverride(options, journal.failure.code);
-    if (journal.intentDigest !== digest && !overrideResumesRecordedFailure) return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
+    if (journal.intentDigest !== digest) return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
   } else {
     let metadata: TaskWriteMetadata;
     try { metadata = (options.metadataProvider ?? captureTaskWriteMetadata)(); }
@@ -522,7 +557,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     }
     journal = { version: 1, taskId, intent: request.intent, intentDigest: digest, sourceState, targetState: spec.target, metadata, completedSteps: [] };
     if (request.dryRun) {
-      const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
+      const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, false);
       if ('code' in plannedMutations) return failed(request, plannedMutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
       const taskPlan = writeTask(
         { taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations: plannedMutations, dryRun: true },
@@ -558,7 +593,7 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
   if (matchingCompletion(io.readFileSync(path.join(sourcePath, 'task.md')), request, restoredFiles)) completed.add('task-written');
   if (!completed.has('task-written')) {
     const current = io.readFileSync(path.join(sourcePath, 'task.md'));
-    const mutations = mutationsFor(request, current, journal.metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
+    const mutations = mutationsFor(request, current, journal.metadata, restoredFiles, false);
     if ('code' in mutations) return failed(request, mutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0 });
     const writeResult = writeTask(
       { taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations },
@@ -574,6 +609,16 @@ function applyTaskLifecycle(requestInput: TaskLifecycleRequest, options: TaskLif
     try { writeJournal(journalPath, journal, io); }
     catch (error) { return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion }); }
   }
+  if (options.prepareOnly && !completed.has('directory-moved')) {
+    return {
+      ...failed(request, { code: '', message: '' }), status: 'applied', changed: true, error: null,
+      taskId, sourceState, targetState: spec.target, sourcePath, targetPath,
+      task: { operations: taskOperations }, directory: { effect: 'unchanged', changed: false },
+      shortId: { effect: 'unchanged', shortId: null, changed: false },
+      timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion,
+      journalPath, completedSteps: [...completed], pendingSteps: STEPS.filter((step) => !completed.has(step))
+    };
+  }
   if (fs.existsSync(targetPath) && !fs.existsSync(sourcePath)) completed.add('directory-moved');
   if (!completed.has('directory-moved')) {
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });

package/lib/task/local-artifact-finalization.ts

@@ -2,14 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { inspectDecisionDetailDuplicates } from './decision-details.ts';
-import { scanVisibleMarkdown } from './markdown.ts';
 import { parseArtifactName } from './artifact-name.ts';
-import {
-  hasOpenArtifactRound,
-} from './artifact-lifecycle.ts';
+import { parseLifecyclePathDecision } from './lifecycle-path.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.ts';
-import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.ts';
+import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 
 type LocalArtifactFamily = 'analysis' | 'plan' | 'code';
@@ -29,7 +25,7 @@ type LocalArtifactDiagnosticCode =
   | 'LOCAL_REQUIRED_PATTERN_MISSING'
   | 'LOCAL_STRUCTURAL_INVALID'
   | 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION'
-  | 'LOCAL_QUALIFICATION_AUDIT_INVALID';
+  | 'LOCAL_FLOW_DECISION_INVALID';
 
 type LocalArtifactDiagnostic = {
   code: LocalArtifactDiagnosticCode;
@@ -40,8 +36,6 @@ type LocalArtifactDiagnostic = {
 type LocalArtifactValidationOptions = {
   family: LocalArtifactFamily;
   requiredSections?: readonly string[];
-  taskContent?: string;
-  artifact?: string;
 };
 
 type LocalArtifactValidationResult = {
@@ -78,7 +72,9 @@ function localDiagnosticCode(code: string): LocalArtifactDiagnosticCode {
     ARTIFACT_EMPTY: 'LOCAL_ARTIFACT_EMPTY',
     ARTIFACT_MISSING_SECTION: 'LOCAL_ARTIFACT_MISSING_SECTION',
     ARTIFACT_DUPLICATE_SECTION: 'LOCAL_ARTIFACT_DUPLICATE_SECTION',
-    ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION'
+    ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION',
+    ARTIFACT_STATE_CHECK_PATTERN_MISSING: 'LOCAL_STATUS_COMMAND_MISSING',
+    ARTIFACT_REQUIRED_PATTERN_MISSING: 'LOCAL_REQUIRED_PATTERN_MISSING'
   };
   return map[code] ?? 'LOCAL_STRUCTURAL_INVALID';
 }
@@ -87,59 +83,23 @@ function localDiagnostic(item: { code: string; message: string; line: number | n
   return { code: localDiagnosticCode(item.code), message: item.message, line: item.line };
 }
 
-function isStatusPattern(pattern: string): boolean {
-  return pattern === '^\\$ ';
-}
-
 function validateLocalArtifact(
   content: string,
   options: LocalArtifactValidationOptions
 ): LocalArtifactValidationResult {
   const schema = getArtifactSchema(options.family)!;
   const diagnostics: LocalArtifactDiagnostic[] = [];
-  const scanned = scanVisibleMarkdown(content);
-  const structure = inspectArtifactStructure(content, schema);
-  for (const item of structure.diagnostics) diagnostics.push(localDiagnostic(item));
-
-  const statusSection = schema.sections.find((section) => section.id === 'state-check');
-  if (statusSection) {
-    const statusHeading = scanned.headings.find((heading) => (
-      heading.level === 2 && [statusSection.headings.zh, statusSection.headings.en].some((name) => (
-        heading.text === name || heading.text === `${name}:` || heading.text === `${name}：`
-      ))
-    ));
-    if (statusHeading) {
-      const next = scanned.headings.find((candidate) => candidate.start > statusHeading.start && candidate.level <= 2);
-      const body = content.slice(statusHeading.end, next?.start ?? content.length);
-      for (const pattern of schema.requiredPatterns.filter(isStatusPattern)) {
-        if (!new RegExp(pattern, 'm').test(body)) {
-          diagnostics.push({ code: 'LOCAL_STATUS_COMMAND_MISSING', message: `status section '${statusHeading.text}' is missing required command output`, line: content.slice(0, statusHeading.start).split('\n').length });
-        }
-      }
-    }
-  }
-
-  const patternInspection = inspectArtifactPatterns(content, {
-    ...schema,
-    requiredPatterns: schema.requiredPatterns.filter((item) => !isStatusPattern(item))
-  });
-  for (const item of patternInspection.diagnostics) diagnostics.push({ code: 'LOCAL_REQUIRED_PATTERN_MISSING', message: item.message, line: null });
+  const inspection = inspectArtifactContract(content, schema, { scopeStateCheckSection: true });
+  for (const item of inspection.diagnostics) diagnostics.push(localDiagnostic(item));
 
   const decisionDetails = inspectDecisionDetailDuplicates(content);
   if (!decisionDetails.ok) diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, line: null });
 
-  if (options.taskContent !== undefined) {
-    const identity = options.artifact ? parseArtifactName(options.artifact) : null;
-    const expected = identity?.family === options.family && hasOpenArtifactRound(options.taskContent, options.family, identity.round)
-      ? expectedQualificationRelations(options.taskContent, options.family)
-      : undefined;
-    if (expected && !expected.ok) diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${expected.code}: ${expected.message}`, line: null });
-    const qualification = validateQualificationAudit(options.taskContent, content, {
-      family: options.family,
-      artifact: options.artifact,
-      expectedUpstreamRelations: expected?.ok ? expected.relations : undefined
-    });
-    if (!qualification.ok) diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${qualification.code}: ${qualification.message}`, line: null });
+  if (options.family === 'analysis') {
+    const flowDecision = parseLifecyclePathDecision(content);
+    if (flowDecision.status !== 'valid') {
+      diagnostics.push({ code: 'LOCAL_FLOW_DECISION_INVALID', message: flowDecision.message, line: null });
+    }
   }
 
   return {
@@ -182,10 +142,8 @@ function prepareLocalArtifact(
   if (!resolved.ok) return failed(resolved.code, resolved.message);
   const parsed = parseArtifactName(request.artifact);
   if (!parsed || parsed.family !== request.family) return failed('ARTIFACT_IDENTITY_INVALID', `artifact '${request.artifact}' does not match ${request.family}`);
-  let taskContent: string;
   let content: string;
   try {
-    taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
     const artifactPath = path.join(resolved.taskDir, request.artifact);
     if (!fs.statSync(artifactPath).isFile()) return failed('ARTIFACT_NOT_REGULAR', `artifact '${request.artifact}' is not a regular file`);
     content = candidate ?? fs.readFileSync(artifactPath, 'utf8');
@@ -195,7 +153,7 @@ function prepareLocalArtifact(
     return failed('ARTIFACT_IDENTITY_INVALID', 'artifact finalization requires an active task');
   }
   const validation = validateLocalArtifact(content, {
-    family: request.family, requiredSections: request.requiredSections, taskContent, artifact: request.artifact
+    family: request.family, requiredSections: request.requiredSections
   });
   const artifactSha256 = sha256Content(content);
   const result = failedFinalization(request, {

package/lib/task/orchestration.ts

@@ -59,6 +59,7 @@ import { hasOpenLifecycleExecution } from './activity-log.ts';
 import { reconcileTaskInvalidation } from './invalidation-command.ts';
 import type { LifecycleAction, LifecycleFacts } from './capabilities.ts';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
+import { resolveArtifactContext } from './artifact-lifecycle.ts';
 
 type OrchestrationStatus = 'running' | 'paused' | 'completed';
 type ModelPolicySource = Readonly<{
@@ -642,18 +643,14 @@ function validateSavedCurrentDiffBase(
   return null;
 }
 
-function routeFromFacts(facts: LifecycleFacts): Omit<OrchestrationNext, 'requestedModel' | 'requestedReasoningEffort'> | { completion: true } | null {
+function routeFromFacts(facts: LifecycleFacts): Omit<OrchestrationNext, 'requestedModel' | 'requestedReasoningEffort' | 'round' | 'artifact'> | { completion: true } | null {
   const recommendation = recommendNext(facts);
-  if (!recommendation.action) return { completion: true };
+  if (!recommendation.action) return recommendation.reasonCode === 'LIFECYCLE_REVIEWED' ? { completion: true } : null;
   const action = recommendation.action;
   if (action === 'manual-validation' || action === 'validation-run') return null;
-  const family = action === 'analysis' ? 'analysis' : action;
-  const round = maxArtifactRound([
-    ...(facts.artifacts[family] ?? []), ...(facts.staleArtifacts?.[family] ?? [])
-  ], family) + 1;
   const command = action === 'analysis' ? 'analyze-task' : action === 'plan' ? 'plan-task' : action === 'code' ? 'code-task' : action;
   const role = action.startsWith('review-') ? 'reviewer' : 'executor';
-  return { action: command, role, stage: action, round, artifact: artifactName(family, round) };
+  return { action: command, role, stage: action };
 }
 
 function routeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
@@ -786,14 +783,35 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
     return { status: 'completed', changed: true, taskId: resolved.taskId, run: completed, next: null, error: null };
   }
   const action = routed.stage as LifecycleAction;
+  const family = action === 'analysis' ? 'analysis' : action;
+  const artifactContext = resolveArtifactContext(taskRef, family, {
+    repoRoot: resolved.repoRoot
+  });
+  if (artifactContext.status !== 'ready' || !artifactContext.selection) {
+    return failed(
+      artifactContext.error?.code ?? 'ORCHESTRATION_ARTIFACT_SELECTION_FAILED',
+      artifactContext.error?.message ?? 'cannot determine artifact selection',
+      resolved.taskId
+    );
+  }
+  if (artifactContext.selection.disposition === 'reuse') {
+    return failed(
+      'ORCHESTRATION_REUSE_STALLED',
+      `lifecycle still routes to ${action} after reusing ${artifactContext.selection.artifact.name}`,
+      resolved.taskId
+    );
+  }
+  const selected = artifactContext.selection.artifact;
   const capability = canStart(action, facts.facts, {
-    initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${routed.round}`,
+    initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${selected.round}`,
     requestedAction: action, reasonCode: 'user-request', explicitRequest: true
   });
   if (!capability.allowed) return failed('ORCHESTRATION_CAPABILITY_DENIED', `${capability.reasonCode}: ${capability.evidence.join(', ')}`, resolved.taskId);
   const policy = run ? rolePolicy(run, routed.role) : null;
   const next: OrchestrationNext = {
     ...routed,
+    round: selected.round,
+    artifact: selected.name,
     requestedModel: policy?.model ?? null,
     requestedReasoningEffort: policy?.reasoningEffort ?? null
   };

package/lib/task/review-command.ts

@@ -1,13 +1,10 @@
 import type { ReviewFinalizationRequest } from './review-finalization.ts';
 
-export function parseReviewCommand(args: readonly string[]): ReviewFinalizationRequest & {
-  overrideTicket?: string; overrideTarget?: string; overrideScope?: string;
-} {
+export function parseReviewCommand(args: readonly string[]): ReviewFinalizationRequest {
   if (!args[0] || !['preflight', 'finalize-summary'].includes(args[1] ?? '')) throw new Error('task ref and a supported review operation are required');
   const values: Record<string, string | boolean> = {};
   const flags = {
-    '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun',
-    '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+    '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
   } as const;
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;

package/lib/task/review-finalization.ts

@@ -12,11 +12,8 @@ import { resolveTaskRef } from './resolve-ref.ts';
 import { validateLifecycleExecution } from './lifecycle-execution.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import type { ResolveTaskRefErrorCode } from './resolve-ref.ts';
-import { allowsManualOverride } from './guard-override.ts';
-import type { ManualOverrideCapability } from './guard-override.ts';
 import { getArtifactSchema } from './artifact-schema.ts';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.ts';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.ts';
 
 type ReviewFinalizationErrorCode =
   | ResolveTaskRefErrorCode
@@ -30,7 +27,6 @@ type ReviewFinalizationErrorCode =
   | 'REVIEW_SUMMARY_PLACEHOLDER_INVALID'
   | 'REVIEW_SUMMARY_COUNT_MISMATCH'
   | 'REVIEW_ARTIFACT_STRUCTURE_INVALID'
-  | 'REVIEW_ARTIFACT_QUALIFICATION_INVALID'
   | 'REVIEW_DECISION_DETAIL_INVALID'
   | 'REVIEW_ARTIFACT_CONFLICT'
   | 'REVIEW_PROVENANCE_INVALID'
@@ -72,7 +68,6 @@ type ReviewFileSystem = {
 type ReviewFinalizationOptions = {
   repoRoot?: string;
   fileSystem?: Partial<ReviewFileSystem>;
-  manualOverride?: ManualOverrideCapability;
   lockAlreadyHeld?: boolean;
 };
 
@@ -143,10 +138,8 @@ function preflightReviewSummaryUnlocked(
   const publicationError = validateArtifactPublication(resolved.taskDir, spec.family, request.artifact);
   if (publicationError) return preflightFailed(request, 'REVIEW_ARTIFACT_IDENTITY_INVALID', publicationError.message, resolved.taskId);
 
-  let taskContent: string;
   let content: string;
   try {
-    taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
     const validated = validateCompletedArtifact(resolved.taskDir, spec.family, request.artifact);
     if (!validated.ok) return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
     content = fs.readFileSync(validated.artifact.path, 'utf8');
@@ -163,21 +156,12 @@ function preflightReviewSummaryUnlocked(
   const semanticDigest = canonicalSemanticDigest(content);
   const detail = inspectDecisionDetailDuplicates(content);
   const structure = inspectArtifactContract(content, getArtifactSchema(spec.family)!);
-  const expected = expectedQualificationRelations(taskContent, spec.family);
-  if (!expected.ok) return preflightFailed(request, 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', `${expected.code}: ${expected.message}`, resolved.taskId, { artifactSha256, semanticDigest });
-  const qualification = validateQualificationAudit(taskContent, content, {
-    family: spec.family,
-    artifact: request.artifact,
-    expectedUpstreamRelations: expected.relations
-  });
-  const qualificationError = qualification.ok ? null : qualification;
-  if (!detail.ok || !structure.ok || qualificationError) {
+  if (!detail.ok || !structure.ok) {
     const diagnostics = [
       ...(!detail.ok ? [`${detail.code}: ${detail.message}`] : []),
-      ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`),
-      ...(qualificationError ? [`${qualificationError.code}: ${qualificationError.message}`] : [])
+      ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`)
     ].join('; ');
-    return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : !structure.ok ? 'REVIEW_ARTIFACT_STRUCTURE_INVALID' : 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', diagnostics, resolved.taskId, {
+    return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : 'REVIEW_ARTIFACT_STRUCTURE_INVALID', diagnostics, resolved.taskId, {
       artifactSha256, semanticDigest,
     });
   }
@@ -237,7 +221,7 @@ function prepareReviewSummaryCandidate(
   const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
   taskId = resolved.taskId ?? null;
   if (!resolved.ok) return reject(resolved.code, resolved.message);
-  if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'review-finalization', 'TASK_STATE_MISMATCH')) {
+  if (resolved.state !== 'active') {
     return reject('TASK_STATE_MISMATCH', `task ${taskId} is ${resolved.state}, expected active`);
   }
   const parsed = parseArtifactName(request.artifact);

package/lib/task/rework-intent.ts

@@ -1,9 +1,14 @@
 const REWORK_INTENT_HEADINGS = ['返工意图', 'Rework Intent'] as const;
 const REWORK_INTENT_COLUMNS = [
+  'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
+  'classification', 'evidence_digest', 'task_fact_digest', 'status', 'declared_at', 'consumed_at'
+] as const;
+const LEGACY_REWORK_INTENT_COLUMNS = [
   'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
   'status', 'declared_at', 'consumed_at'
 ] as const;
-type ReworkTarget = 'analysis' | 'plan' | 'code';
+type ReworkTarget = 'analysis' | 'plan' | 'code' | 'pause';
+type ReworkClassification = 'scope-or-requirement' | 'design' | 'implementation' | 'human-decision' | 'insufficient-evidence';
 type ReworkIntentStatus = 'pending' | 'consumed' | 'superseded';
 type ReworkIntent = {
   intentId: string;
@@ -11,6 +16,9 @@ type ReworkIntent = {
   sourceArtifact: string;
   sourceSha256: string;
   target: ReworkTarget;
+  classification?: ReworkClassification;
+  evidenceDigest?: string;
+  taskFactDigest?: string;
   status: ReworkIntentStatus;
   declaredAt: string;
   consumedAt: string;
@@ -66,15 +74,19 @@ function parseReworkIntentDocument(content: string): ReworkIntentParseResult {
       const row = Object.fromEntries(REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]!])) as Record<string, string>;
       if (!/^RI-[1-9]\d*$/.test(row.intent_id!)) throw new Error(`invalid intent id '${row.intent_id}'`);
       if (!/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id!)) throw new Error(`invalid finding id '${row.finding_id}'`);
-      if (!['analysis', 'plan', 'code'].includes(row.target!)) throw new Error(`invalid rework target '${row.target}'`);
+      if (!['analysis', 'plan', 'code', 'pause'].includes(row.target!)) throw new Error(`invalid rework target '${row.target}'`);
+      if (!['scope-or-requirement', 'design', 'implementation', 'human-decision', 'insufficient-evidence'].includes(row.classification!)) throw new Error(`invalid rework classification '${row.classification}'`);
       if (!['pending', 'consumed', 'superseded'].includes(row.status!)) throw new Error(`invalid rework status '${row.status}'`);
       if (!/^[a-f0-9]{64}$/.test(row.source_sha256!)) throw new Error(`invalid source hash for '${row.intent_id}'`);
+      if (!/^[a-f0-9]{64}$/.test(row.evidence_digest!) || !/^[a-f0-9]{64}$/.test(row.task_fact_digest!)) throw new Error(`invalid semantic digest for '${row.intent_id}'`);
       if (!row.source_artifact || !row.declared_at) throw new Error(`rework intent '${row.intent_id}' has invalid required fields`);
       const terminal = row.status === 'consumed' || row.status === 'superseded';
       if (terminal !== Boolean(row.consumed_at)) throw new Error(`rework intent '${row.intent_id}' has invalid consumed_at`);
       return {
         intentId: row.intent_id!, findingId: row.finding_id!, sourceArtifact: row.source_artifact!,
         sourceSha256: row.source_sha256!, target: row.target as ReworkTarget,
+        classification: row.classification as ReworkClassification,
+        evidenceDigest: row.evidence_digest!, taskFactDigest: row.task_fact_digest!,
         status: row.status as ReworkIntentStatus, declaredAt: row.declared_at!, consumedAt: row.consumed_at!
       } satisfies ReworkIntent;
     });
@@ -96,7 +108,10 @@ function renderReworkIntents(intents: readonly ReworkIntent[]): string {
     `| ${REWORK_INTENT_COLUMNS.map(() => '---').join(' | ')} |`,
     ...intents.map((intent) => `| ${[
       intent.intentId, intent.findingId, intent.sourceArtifact, intent.sourceSha256,
-      intent.target, intent.status, intent.declaredAt, intent.consumedAt
+      intent.target, intent.classification ?? (intent.target === 'analysis' ? 'scope-or-requirement' : intent.target === 'plan' ? 'design' : intent.target === 'code' ? 'implementation' : 'insufficient-evidence'),
+      intent.evidenceDigest ?? requireDigest(`${intent.findingId}|${intent.sourceArtifact}|${intent.sourceSha256}`),
+      intent.taskFactDigest ?? requireDigest(`current|${intent.findingId}|${intent.target}`),
+      intent.status, intent.declaredAt, intent.consumedAt
     ].map(escape).join(' | ')} |`)
   ].join('\n');
 }
@@ -104,11 +119,63 @@ function renderReworkIntents(intents: readonly ReworkIntent[]): string {
 function upsertReworkIntent(intents: readonly ReworkIntent[], intent: ReworkIntent): { changed: boolean; intents: readonly ReworkIntent[] } {
   const existing = intents.find((candidate) => candidate.intentId === intent.intentId);
   if (!existing) return { changed: true, intents: [...intents, intent] };
-  const identity = (value: ReworkIntent) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target];
+  const identity = (value: ReworkIntent) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target, value.classification, value.evidenceDigest, value.taskFactDigest];
   if (JSON.stringify(identity(existing)) !== JSON.stringify(identity(intent))) throw new Error(`intent '${intent.intentId}' identity conflicts with existing state`);
   return { changed: false, intents };
 }
 
+function consumeHumanDecisionReworkIntents(
+  intents: readonly ReworkIntent[],
+  findingId: string,
+  consumedAt: string
+): { changed: boolean; intents: readonly ReworkIntent[] } {
+  let changed = false;
+  const next = intents.map((intent) => {
+    if (intent.status !== 'pending' || intent.target !== 'pause' || intent.classification !== 'human-decision' || intent.findingId !== findingId) return intent;
+    changed = true;
+    return { ...intent, status: 'consumed' as const, consumedAt };
+  });
+  return { changed, intents: next };
+}
+
+function parseLegacyReworkIntentDocument(content: string): ReworkIntentParseResult {
+  // TODO(compat): Remove this explicit decoder once no task contains the eight-column rework-intent header.
+  const body = sectionBody(content);
+  if (body === null) return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'legacy rework intent section is missing' };
+  const lines = body.split(/\r?\n/).filter((line) => line.trim());
+  const header = lines[0] ? cells(lines[0]) : null;
+  const separator = lines[1] ? cells(lines[1]) : null;
+  if (!header || !separator || header.length !== LEGACY_REWORK_INTENT_COLUMNS.length || !header.every((value, index) => value === LEGACY_REWORK_INTENT_COLUMNS[index])) {
+    return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'rework intent section is not the known legacy table' };
+  }
+  try {
+    const intents = lines.slice(2).map((line) => {
+      const values = cells(line);
+      if (!values || values.length !== LEGACY_REWORK_INTENT_COLUMNS.length) throw new Error('legacy rework intent row has the wrong column count');
+      const row = Object.fromEntries(LEGACY_REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]!])) as Record<string, string>;
+      if (!/^RI-[1-9]\d*$/.test(row.intent_id!) || !/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id!)) throw new Error('legacy rework intent identity is invalid');
+      if (!['analysis', 'plan', 'code'].includes(row.target!) || !['pending', 'consumed', 'superseded'].includes(row.status!)) throw new Error('legacy rework intent state is invalid');
+      if (!/^[a-f0-9]{64}$/.test(row.source_sha256!)) throw new Error('legacy rework intent source hash is invalid');
+      const legacyDigest = (value: string) => requireDigest(value);
+      const classification: ReworkClassification = row.target === 'analysis' ? 'scope-or-requirement' : row.target === 'plan' ? 'design' : 'implementation';
+      return {
+        intentId: row.intent_id!, findingId: row.finding_id!, sourceArtifact: row.source_artifact!, sourceSha256: row.source_sha256!,
+        target: row.target as ReworkTarget, classification,
+        evidenceDigest: legacyDigest(`${row.finding_id}|${row.source_artifact}|${row.source_sha256}`),
+        taskFactDigest: legacyDigest(`legacy|${row.finding_id}|${row.target}`),
+        status: row.status as ReworkIntentStatus, declaredAt: row.declared_at!, consumedAt: row.consumed_at!
+      } satisfies ReworkIntent;
+    });
+    return { ok: true, present: true, intents };
+  } catch (error) {
+    return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function requireDigest(value: string): string {
+  return createHash('sha256').update(value).digest('hex');
+}
+
 function consumeReworkIntents(
   intents: readonly ReworkIntent[],
   target: ReworkTarget,
@@ -161,5 +228,8 @@ export {
   consumeReworkIntents,
   supersedeReworkIntents,
   upsertReworkIntent
+  , consumeHumanDecisionReworkIntents
+  , parseLegacyReworkIntentDocument
 };
-export type { ReworkIntent, ReworkIntentParseResult, ReworkIntentStatus, ReworkTarget };
+export type { ReworkClassification, ReworkIntent, ReworkIntentParseResult, ReworkIntentStatus, ReworkTarget };
+import { createHash } from 'node:crypto';

package/lib/task/snapshot.ts

@@ -97,22 +97,22 @@ function collectTaskSnapshot(taskRef: string, options: SnapshotOptions = {}): Ta
   const observations: SnapshotObservation[] = [];
   try {
     const output = stripOneTrailingNewline((options.gitStatus ?? defaultGitStatus)(resolved.repoRoot));
-    observations.push({ name: 'git', status: 'ready', command: '$ git status -s', output, error: null });
+    observations.push({ name: 'git', status: 'ready', command: 'git status --short --untracked-files=all', output, error: null });
   } catch (error) {
-    return failedSnapshot(resolved, taskRef, observations, 'git', '$ git status -s', 'SNAPSHOT_GIT_FAILED', error);
+    return failedSnapshot(resolved, taskRef, observations, 'git', 'git status --short --untracked-files=all', 'SNAPSHOT_GIT_FAILED', error);
   }
   try {
     const entries = (options.readDirectory ?? ((dir) => fs.readdirSync(dir, { withFileTypes: true })))(resolved.taskDir);
     const output = renderDirectory(entries, resolved.taskDir, options.lstat ?? fs.lstatSync);
-    observations.push({ name: 'task-directory', status: 'ready', command: `$ ls -la ${taskDirPath}/`, output, error: null });
+    observations.push({ name: 'task-directory', status: 'ready', command: `fs.readdirSync ${taskDirPath}/`, output, error: null });
   } catch (error) {
-    return failedSnapshot(resolved, taskRef, observations, 'task-directory', `$ ls -la ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
+    return failedSnapshot(resolved, taskRef, observations, 'task-directory', `fs.readdirSync ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
   }
   try {
     const content = (options.readTask ?? ((file) => fs.readFileSync(file, 'utf8')))(resolved.taskMdPath);
-    observations.push({ name: 'task-tail', status: 'ready', command: `$ tail ${taskPath}`, output: renderTail(content), error: null });
+    observations.push({ name: 'task-tail', status: 'ready', command: `fs.readFileSync ${taskPath} (last 10 lines)`, output: renderTail(content), error: null });
   } catch (error) {
-    return failedSnapshot(resolved, taskRef, observations, 'task-tail', `$ tail ${taskPath}`, 'SNAPSHOT_TASK_READ_FAILED', error);
+    return failedSnapshot(resolved, taskRef, observations, 'task-tail', `fs.readFileSync ${taskPath} (last 10 lines)`, 'SNAPSHOT_TASK_READ_FAILED', error);
   }
   return {
     status: 'ready', changed: false, requestRef: taskRef, taskId: resolved.taskId,