@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/lib/task/commands/status.ts

@@ -12,6 +12,9 @@ import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-lo
 import { readRun, type OrchestrationRun } from '../orchestration.ts';
 import type { DelegationReceipt } from '../delegation-receipts.ts';
 import { statusCard, type DisplayMessage } from '../../server/display.ts';
+import { invalidationBlocks, parseInvalidationDocument } from '../invalidation.ts';
+import { parseReworkIntentDocument } from '../rework-intent.ts';
+import { buildLifecycleFacts, recommendNext } from '../capabilities.ts';
 
 const USAGE = `Usage: ai task status [--task <ref> | -t <ref>]
 
@@ -381,6 +384,8 @@ type StatusModel = {
   workflow: WorkflowInfo;
   runtime: RuntimeInfo;
   orchestration: OrchestrationInfo;
+  invalidation?: { status: string; processed: number; total: number; pendingIntents: number };
+  recommendation?: string;
   git: GitInfo;
 };
 
@@ -429,6 +434,18 @@ function renderStatus(model: StatusModel): string[] {
     lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
   }
 
+  lines.push(
+    '',
+    'Invalidation',
+    ...renderPairs([
+      ['status', model.invalidation?.status ?? 'unknown'],
+      ['processed', `${model.invalidation?.processed ?? 0}/${model.invalidation?.total ?? 0}`],
+      ['pending_intents', String(model.invalidation?.pendingIntents ?? 0)]
+    ])
+  );
+
+  lines.push('', 'Recommendation', ...renderPairs([['action', model.recommendation ?? DASH]]));
+
   lines.push(
     '',
     'Orchestration',
@@ -494,6 +511,8 @@ function renderStatus(model: StatusModel): string[] {
 }
 
 function modelTone(model: StatusModel): 'info' | 'success' | 'warning' | 'danger' | 'running' {
+  if (model.invalidation?.status === 'invalid') return 'danger';
+  if (model.invalidation?.status === 'pending' || model.invalidation?.status === 'in-progress') return 'warning';
   if (model.orchestration.status === 'paused') return 'warning';
   if (model.orchestration.status === 'running') return 'running';
   if (model.orchestration.status === 'completed') return 'success';
@@ -511,6 +530,23 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
   const run = input.run ?? makeRunner(input.repoRoot);
   const artifacts = enumerateArtifacts(input.taskDir);
   const workflow = collectWorkflow(content, input.now);
+  const invalidation = parseInvalidationDocument(content);
+  const rework = parseReworkIntentDocument(content);
+  const pendingIntents = rework.ok ? rework.intents.filter((intent) => intent.status === 'pending').length : 0;
+  const invalidationInfo = !invalidation.ok
+    ? { status: 'invalid', processed: 0, total: 0, pendingIntents }
+    : {
+        status: invalidation.present
+          ? invalidationBlocks(invalidation.document)
+            ? invalidation.document.operations.some((operation) => operation.status === 'in-progress') ? 'in-progress' : 'pending'
+            : 'completed'
+          : 'none',
+        processed: invalidation.document.operations.reduce((sum, operation) => sum + operation.processed, 0),
+        total: invalidation.document.operations.reduce((sum, operation) => sum + operation.total, 0),
+        pendingIntents
+      };
+  const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active');
+  const recommendation = facts.ok ? (recommendNext(facts.facts).action ?? DASH) : DASH;
 
   return {
     taskId: input.taskId,
@@ -522,6 +558,8 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
     workflow,
     runtime: collectRuntime(input.taskDir, workflow, run),
     orchestration: collectOrchestration(input.taskDir),
+    invalidation: invalidationInfo,
+    recommendation,
     git: collectGit(fm.branch ?? '', run)
   };
 }

package/lib/task/commit-operation.ts

@@ -210,7 +210,18 @@ function syncTaskCommit(
     );
     const metadata = captureTaskWriteMetadata();
     const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
-    const alreadyLogged = activity.entries.some((entry) => entry.step === 'Commit' && entry.note === commitNote);
+    let matchingCommitIndex = -1;
+    for (let index = activity.entries.length - 1; index >= 0; index -= 1) {
+      const entry = activity.entries[index]!;
+      if (entry.step === 'Commit' && entry.note === commitNote) {
+        matchingCommitIndex = index;
+        break;
+      }
+    }
+    const reviewedAfterCommit = matchingCommitIndex >= 0 && activity.entries
+      .slice(matchingCommitIndex + 1)
+      .some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
+    const alreadyLogged = matchingCommitIndex >= 0 && !reviewedAfterCommit;
     const mutations: TaskMutation[] = [];
     if (!alreadyLogged) mutations.push({
       kind: 'section',

package/lib/task/control-authority.ts

@@ -20,7 +20,11 @@ import {
   sealOrchestrationDelegation,
   statusOrchestration
 } from './orchestration.ts';
-import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
+import type {
+  OrchestrationDiagnosticLogger,
+  OrchestrationOptions,
+  OrchestrationResult
+} from './orchestration.ts';
 import { prepareCodexOrchestrationDelegation } from './codex-orchestration.ts';
 import {
   applyTaskFinalization,
@@ -60,6 +64,7 @@ export type TaskControlExecutionContext =
       generation: string;
       manifestPath: string;
       requestId: string;
+      diagnosticLog?: OrchestrationDiagnosticLogger;
       controllerBinding?: TaskControlControllerBinding | null;
     }>;
 
@@ -134,6 +139,7 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
   generation: string;
   manifestPath: string;
   requestId: string;
+  diagnosticLog?: OrchestrationDiagnosticLogger;
   controllerBinding?: TaskControlControllerBinding | null;
 }>): TaskControlExecutionContext {
   if (!/^TASK-\d{8}-\d{6}$/u.test(params.taskId) || !params.generation || !params.requestId) {
@@ -153,6 +159,7 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
     generation: params.generation,
     manifestPath: absolute('manifestPath', params.manifestPath),
     requestId: params.requestId,
+    ...(params.diagnosticLog === undefined ? {} : { diagnosticLog: params.diagnosticLog }),
     ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) })
   };
 }
@@ -192,6 +199,9 @@ function domainOptions(
   return {
     ...options,
     repoRoot: context.repoRoot,
+    ...(context.source === 'sandbox-executor' && context.diagnosticLog !== undefined
+      ? { diagnosticLog: context.diagnosticLog }
+      : {}),
     ...(context.source === 'sandbox-executor' ? { gitWorktreeRoot: context.worktreeRoot } : {})
   };
 }
@@ -206,15 +216,15 @@ function lifecycleTaskId(request: TaskLifecycleControlRequest, repoRoot: string)
   }
 }
 
-function applyLifecycleWithAuthority(
+async function applyLifecycleWithAuthority(
   context: TaskControlExecutionContext,
   request: TaskLifecycleControlRequest
-): TaskLifecycleResult & { humanOverride?: unknown } {
+): Promise<TaskLifecycleResult & { humanOverride?: unknown }> {
   const conflict = overrideDryRunConflict(request as unknown as Record<string, unknown>);
   if (conflict) {
     return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
   }
-  const execute = (): TaskLifecycleResult & { humanOverride?: unknown } => {
+  const execute = async (): Promise<TaskLifecycleResult & { humanOverride?: unknown }> => {
     const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
     if (lifecycleResult.status !== 'failed' || !request.overrideTicket) return lifecycleResult;
     if (!request.overrideTarget || !request.overrideScope) {
@@ -223,7 +233,7 @@ function applyLifecycleWithAuthority(
         error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
       };
     }
-    const override = consumeHumanOverride({
+    const override = await consumeHumanOverride({
       taskRef: request.taskRef,
       ticketId: request.overrideTicket,
       failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
@@ -238,9 +248,9 @@ function applyLifecycleWithAuthority(
     return { ...lifecycleResult, ...override, humanOverride: override, error: null };
   };
   const taskId = lifecycleTaskId(request, context.repoRoot);
-  if (!taskId) return execute();
+  if (!taskId) return await execute();
   try {
-    return withTaskExecutionLock(
+    return await withTaskExecutionLock(
       context.repoRoot,
       taskId,
       `task-lifecycle.${request.intent}`,
@@ -322,11 +332,11 @@ function orchestrationFailure(error: unknown): OrchestrationResult {
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-lifecycle' }>
-): TaskLifecycleResult;
+): Promise<TaskLifecycleResult & { humanOverride?: unknown }>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-finalization' }>
-): TaskFinalizationResult;
+): Promise<TaskFinalizationResult>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-orchestration' }>
@@ -345,6 +355,9 @@ export function dispatchTaskControlOperation(
     operationTaskId(context, operation.request.taskRef);
     return applyTaskFinalization(operation.request, {
       repoRoot: context.repoRoot,
+      ...(context.source === 'sandbox-executor' ? {
+        controlBinding: { generation: context.generation, requestId: context.requestId }
+      } : {}),
       preflight: (request, options) => verifyTaskEvent(
         { ...request, event: 'complete-task.hard-preflight' }, options
       )

package/lib/task/create-service.ts

@@ -12,6 +12,13 @@ import { verifyTaskEvent } from './verification.ts';
 type TaskCreateStatus = 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
 type TaskCreateOperation = { name: string; status: string; reasonCode: string | null };
 type TaskCreateWarning = { code: string; severity: string; action: string };
+type TaskCreateRecovery = 'none' | 'same-request-id' | 'new-request-id' | 'inspect-domain-state';
+type TaskCreateControl = Readonly<{
+  requestId: string | null;
+  accepted: boolean;
+  recovery: TaskCreateRecovery;
+}>;
+type TaskCreateError = { code: string; message: string; retryable: boolean };
 type TaskCreateResult = Readonly<{
   status: TaskCreateStatus;
   changed: boolean;
@@ -19,7 +26,8 @@ type TaskCreateResult = Readonly<{
   issue: { number: number; url: string } | null;
   operations: readonly TaskCreateOperation[];
   warnings: readonly TaskCreateWarning[];
-  error: { code: string; message: string; retryable: boolean } | null;
+  error: TaskCreateError | null;
+  control?: TaskCreateControl;
 }>;
 
 type CreateTaskOptions = Readonly<{
@@ -42,8 +50,118 @@ const DEFAULT_DEPENDENCIES: TaskCreateDependencies = {
   addWarning: applyWorkflowWarningIntent
 };
 
-function verifyCreatedTask(repoRoot: string, taskId: string): { operation: TaskCreateOperation; error: TaskCreateResult['error'] } {
-  const verification = verifyTaskEvent(
+function invalidTaskCreateResult(): never {
+  throw new Error('TASK_CREATE_RESULT_INVALID');
+}
+
+function exactKeys(value: Record<string, unknown>, expected: readonly string[]): boolean {
+  return Object.keys(value).sort().join(',') === [...expected].sort().join(',');
+}
+
+function validTaskReference(value: unknown): boolean {
+  return value === null || (typeof value === 'string' && value.length > 0);
+}
+
+function validTaskCreateError(value: unknown): value is TaskCreateError {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const error = value as Record<string, unknown>;
+  return exactKeys(error, ['code', 'message', 'retryable'])
+    && typeof error.code === 'string' && /^[A-Z][A-Z0-9_]+$/u.test(error.code)
+    && typeof error.message === 'string'
+    && typeof error.retryable === 'boolean';
+}
+
+function validTaskCreateControl(value: unknown): value is TaskCreateControl {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const control = value as Record<string, unknown>;
+  return exactKeys(control, ['accepted', 'recovery', 'requestId'])
+    && validTaskReference(control.requestId)
+    && typeof control.accepted === 'boolean'
+    && ['none', 'same-request-id', 'new-request-id', 'inspect-domain-state'].includes(control.recovery as string);
+}
+
+export function parseTaskCreateResult(value: unknown): TaskCreateResult {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return invalidTaskCreateResult();
+  const result = value as Record<string, unknown>;
+  if (!exactKeys(result, ['changed', 'control', 'error', 'issue', 'operations', 'status', 'task', 'warnings'])
+    && !exactKeys(result, ['changed', 'error', 'issue', 'operations', 'status', 'task', 'warnings'])) {
+    return invalidTaskCreateResult();
+  }
+  if (!['applied', 'no-op', 'degraded', 'failed', 'blocked'].includes(result.status as string)
+    || typeof result.changed !== 'boolean'
+    || !result.task || typeof result.task !== 'object' || Array.isArray(result.task)
+    || !exactKeys(result.task as Record<string, unknown>, ['id', 'shortId'])
+    || !validTaskReference((result.task as { id?: unknown }).id)
+    || !validTaskReference((result.task as { shortId?: unknown }).shortId)
+    || !Array.isArray(result.operations)
+    || !result.operations.every((operation) => {
+      if (!operation || typeof operation !== 'object' || Array.isArray(operation)) return false;
+      const value = operation as Record<string, unknown>;
+      return exactKeys(value, ['name', 'reasonCode', 'status'])
+        && typeof value.name === 'string' && typeof value.status === 'string'
+        && (value.reasonCode === null || typeof value.reasonCode === 'string');
+    })
+    || !Array.isArray(result.warnings)
+    || !result.warnings.every((warning) => {
+      if (!warning || typeof warning !== 'object' || Array.isArray(warning)) return false;
+      const value = warning as Record<string, unknown>;
+      return exactKeys(value, ['action', 'code', 'severity'])
+        && typeof value.action === 'string' && typeof value.code === 'string' && typeof value.severity === 'string';
+    })
+    || (result.issue !== null && (
+      !result.issue || typeof result.issue !== 'object' || Array.isArray(result.issue)
+      || !exactKeys(result.issue as Record<string, unknown>, ['number', 'url'])
+      || !Number.isSafeInteger((result.issue as { number?: unknown }).number)
+      || ((result.issue as { number: number }).number) <= 0
+      || typeof (result.issue as { url?: unknown }).url !== 'string'
+    ))
+    || (result.error !== null && !validTaskCreateError(result.error))
+    || ('control' in result && !validTaskCreateControl(result.control))) {
+    return invalidTaskCreateResult();
+  }
+  if (result.status === 'blocked' && !(result.error as TaskCreateError | null)?.retryable) return invalidTaskCreateResult();
+  if (result.status === 'failed' && !(result.error as TaskCreateError | null)) return invalidTaskCreateResult();
+  return result as unknown as TaskCreateResult;
+}
+
+export function projectTaskCreateResult(result: TaskCreateResult, control: TaskCreateControl): TaskCreateResult {
+  return { ...result, control };
+}
+
+export function taskCreateExitCode(result: Pick<TaskCreateResult, 'status'>): number {
+  return result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+}
+
+export function taskCreateFailure(
+  error: TaskCreateError,
+  control?: TaskCreateControl
+): TaskCreateResult {
+  return {
+    status: error.retryable ? 'blocked' : 'failed',
+    changed: false,
+    task: { id: null, shortId: null },
+    issue: null,
+    operations: [],
+    warnings: [],
+    error,
+    ...(control ? { control } : {})
+  };
+}
+
+export function taskCreateOutputUnavailableResult(requestId: string): TaskCreateResult {
+  return taskCreateFailure({
+    code: 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE',
+    message: 'SANDBOX_CONTROL_OUTPUT_UNAVAILABLE: task-create result output was not retained; inspect domain state before retrying',
+    retryable: false
+  }, {
+    requestId,
+    accepted: true,
+    recovery: 'inspect-domain-state'
+  });
+}
+
+async function verifyCreatedTask(repoRoot: string, taskId: string): Promise<{ operation: TaskCreateOperation; error: TaskCreateResult['error'] }> {
+  const verification = await verifyTaskEvent(
     { taskRef: taskId, event: 'create-task.completed' },
     { repoRoot }
   );
@@ -78,7 +196,7 @@ function issueFromTask(repoRoot: string, taskId: string): { number: number; url:
   return match ? { number: Number(match[1]), url: '' } : null;
 }
 
-function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResult {
+async function createTask(value: unknown, options: CreateTaskOptions): Promise<TaskCreateResult> {
   const dependencies = { ...DEFAULT_DEPENDENCIES, ...options.dependencies };
   let candidate: TaskCreateCandidateV1;
   let local;
@@ -91,23 +209,20 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_FAILED';
-    return {
-      status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
-      operations: [], warnings: [], error: { code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' }
-    };
+    return taskCreateFailure({ code, message, retryable: code === 'TASK_CREATE_LOCK_TIMEOUT' });
   }
 
   const operations: TaskCreateOperation[] = [{
     name: 'task:local', status: local.status, reasonCode: null
   }];
   let issue = issueFromTask(options.repoRoot, local.task.id);
-  const created = dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
+  const created = await dependencies.createIssue(local.task.id, { cwd: options.repoRoot, agent: candidate.agent });
   operations.push(...platformOperations('platform-create', created.operations));
   if (created.issue) issue = { number: created.issue.number, url: created.issue.url };
 
   let platformFailure: PlatformResult | null = created.status === 'failed' || created.status === 'blocked' ? created : null;
   if (!platformFailure && (created.task.issueNumber || issue)) {
-    const synced = dependencies.syncIssue(local.task.id, {
+    const synced = await dependencies.syncIssue(local.task.id, {
       cwd: options.repoRoot,
       agent: candidate.agent,
       status: 'waiting-for-triage',
@@ -120,7 +235,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
     if (synced.issue) issue = { number: synced.issue.number, url: synced.issue.url };
     if (synced.status === 'failed' || synced.status === 'blocked') platformFailure = synced;
     if (!platformFailure) {
-      const commented = dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
+      const commented = await dependencies.syncComment(local.task.id, { cwd: options.repoRoot, kind: 'task', agent: candidate.agent });
       operations.push(...platformOperations('platform-comment', commented.operations));
       if (commented.status === 'failed' || commented.status === 'blocked') platformFailure = commented;
     }
@@ -133,7 +248,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
       code: 'ISSUE_CREATE_FAILED', target: 'issue', message: `${error.code}: ${error.message}`,
       action: 'Fix platform authentication or connectivity, then retry Issue creation for this task.'
     }, { repoRoot: options.repoRoot });
-    const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+    const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
     operations.push(verified.operation);
     if (verified.error) return {
       status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
@@ -150,7 +265,7 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
     };
   }
 
-  const verified = verifyCreatedTask(options.repoRoot, local.task.id);
+  const verified = await verifyCreatedTask(options.repoRoot, local.task.id);
   operations.push(verified.operation);
   if (verified.error) return {
     status: verified.error.retryable ? 'blocked' : 'failed', changed: local.changed,
@@ -168,4 +283,14 @@ function createTask(value: unknown, options: CreateTaskOptions): TaskCreateResul
 }
 
 export { createTask };
-export type { CreateTaskOptions, TaskCreateDependencies, TaskCreateOperation, TaskCreateResult, TaskCreateStatus, TaskCreateWarning };
+export type {
+  CreateTaskOptions,
+  TaskCreateControl,
+  TaskCreateDependencies,
+  TaskCreateError,
+  TaskCreateOperation,
+  TaskCreateRecovery,
+  TaskCreateResult,
+  TaskCreateStatus,
+  TaskCreateWarning
+};

package/lib/task/create.ts

@@ -7,6 +7,7 @@ import { loadShortIdByTaskId, mutateShortIdRegistry } from './short-id.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { readDeliveryDefaults, validateBaseRef, validateRemote } from './delivery-target.ts';
 import { buildUnboundFact, encodePrDeliveryFact } from './pr-delivery-fact.ts';
+import { CANDIDATE_COLUMNS, CONSTRAINT_COLUMNS } from './qualification-audit.ts';
 
 const AGENTS = ['claude', 'codex', 'antigravity', 'opencode', 'cursor'] as const;
 const TYPES = ['feature', 'bugfix', 'refactor', 'docs', 'chore'] as const;
@@ -178,6 +179,25 @@ function renderList(items: readonly string[]): string {
   return items.map((item) => `- ${item}`).join('\n');
 }
 
+function tableCell(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/[\r\n]/g, ' ');
+}
+
+function renderTable(columns: readonly string[], rows: readonly (readonly string[])[]): string {
+  return [
+    `| ${columns.join(' | ')} |`,
+    `| ${columns.map(() => '---').join(' | ')} |`,
+    ...rows.map((row) => `| ${row.map(tableCell).join(' | ')} |`)
+  ].join('\n');
+}
+
+function appendCanonicalRows(content: string, columns: readonly string[], rows: readonly (readonly string[])[]): string {
+  if (rows.length === 0) return content;
+  const table = renderTable(columns, rows);
+  const separator = `| ${columns.map(() => '---').join(' | ')} |`;
+  return content.replace(separator, `${separator}\n${table.split('\n').slice(2).join('\n')}`);
+}
+
 function replaceEmptySubsection(content: string, heading: string, items: readonly string[]): string {
   if (items.length === 0) return content;
   return content.replace(`${heading}\n`, `${heading}\n\n${renderList(items)}\n`);
@@ -231,6 +251,13 @@ function renderTask(params: Readonly<{
     ['### 验收标准', 'acceptanceCriteria'], ['### 未决事项', 'openQuestions']
   ];
   for (const [heading, key] of sections) content = replaceEmptySubsection(content, heading, candidate.taskInput[key]);
+  const constraintIds = candidate.taskInput.constraints.map((_, index) => `C-${index + 1}`);
+  content = appendCanonicalRows(content, CONSTRAINT_COLUMNS, candidate.taskInput.constraints.map((statement, index) => [
+    constraintIds[index]!, statement, 'assumption', 'create-task', 'taskInput', 'create-task input', '', ''
+  ]));
+  content = appendCanonicalRows(content, CANDIDATE_COLUMNS, candidate.taskInput.alternatives.map((statement, index) => [
+    String.fromCharCode(65 + index), statement, 'pending', constraintIds.join(','), 'requires qualification', 'create-task input'
+  ]));
   content = content.replace('- **关联 Issue**：#XXX', '- **关联 Issue**：N/A');
   content = content.replace('- **关联 PR**：#XXX', '- **关联 PR**：N/A');
   content = content.replace('- **分支**：`feature/xxx`', `- **分支**：\`${branch}\``);

package/lib/task/current-contract.ts

@@ -2,6 +2,8 @@ import { isValidAgentInfraVersion } from '../version.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, validateLedgerRows } from './ledger.ts';
 import type { LedgerDocument } from './ledger.ts';
+import { parseInvalidationDocument } from './invalidation.ts';
+import type { InvalidationDocument } from './invalidation.ts';
 
 type CurrentTaskContractErrorCode = 'TASK_DOCUMENT_INVALID' | 'TASK_CURRENT_CONTRACT_INVALID';
 type CurrentTaskContractResult =
@@ -9,6 +11,7 @@ type CurrentTaskContractResult =
       ok: true;
       metadata: ReturnType<typeof parseTypedTaskFrontmatter>;
       ledger: LedgerDocument;
+      invalidation: InvalidationDocument;
     }
   | {
       ok: false;
@@ -42,7 +45,9 @@ function validateCurrentTaskContract(content: string): CurrentTaskContractResult
   }
   const invalid = validateLedgerRows(ledger.rows);
   if (invalid) return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalid.code}: ${invalid.message}` };
-  return { ok: true, metadata, ledger };
+  const invalidation = parseInvalidationDocument(content);
+  if (!invalidation.ok) return { ok: false, code: 'TASK_CURRENT_CONTRACT_INVALID', message: `${invalidation.code}: ${invalidation.message}` };
+  return { ok: true, metadata, ledger, invalidation: invalidation.document };
 }
 
 export { validateCurrentTaskContract };

package/lib/task/decision-details.ts

@@ -270,11 +270,15 @@ export {
   normalizeDecisionDetailForDisplay,
   parseDecisionDetailBlocks,
   parseDecisionEvidence,
-  resolveDecisionDetail
+  resolveDecisionDetail,
+  scanVisibleMarkdown
 };
 export type {
   DecisionDetailBlock,
   DecisionDetailDuplicate,
   DecisionDetailInspection,
-  DecisionDetailResolution
+  DecisionDetailResolution,
+  SourceLine,
+  VisibleHeading,
+  VisibleMarkdown
 };