@fitlab-ai/agent-infra 0.11.2 → 0.11.4

package/lib/internal/task-finalization.ts

@@ -3,8 +3,11 @@ import {
   dispatchTaskControlOperation,
   parseTaskControlOperation
 } from '../task/control-authority.ts';
-import { applyTaskFinalization } from '../task/finalization.ts';
+import { applyTaskFinalization, prepareTaskFinalization } from '../task/finalization.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
+import { verifyTaskEvent } from '../task/verification.ts';
+import { resolveSandboxControlTransport } from './task-operation-registry.ts';
+import { requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
@@ -73,10 +76,46 @@ async function taskFinalization(args: string[] = []): Promise<void> {
     ...operation,
     request: { ...operation.request, taskRef: resolved.taskId }
   };
+  const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
+  if (transport.kind === 'sandbox-local') {
+    const prepared = await prepareTaskFinalization(boundOperation.request, {
+      repoRoot,
+      preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
+    });
+    if (prepared.status !== 'prepared') {
+      process.stdout.write(envelope(prepared.status, prepared.changed, true, prepared, prepared.error));
+      process.exitCode = exitCode(prepared.status);
+      return;
+    }
+    try {
+      const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
+      process.stdout.write(response.stdout);
+      process.stderr.write(response.stderr);
+      process.exitCode = response.exitCode ?? 1;
+      return;
+    } catch (error) {
+      const detail = error instanceof SandboxControlClientError
+        ? error.detail
+        : { code: 'SANDBOX_CONTROL_CLIENT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
+      process.stdout.write(envelope(detail.retryable ? 'blocked' : 'failed', false, false, null, detail));
+      process.exitCode = detail.retryable ? 2 : 1;
+      return;
+    }
+  }
   const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     boundOperation
   );
+  if (result.status === 'prepared') {
+    const detail = {
+      code: 'TASK_FINALIZATION_DIRECT_COMMIT_REQUIRED',
+      message: 'direct finalization prepared external work without committing the lifecycle transition',
+      retryable: false
+    };
+    process.stdout.write(envelope('failed', result.changed, true, result, detail));
+    process.exitCode = 1;
+    return;
+  }
   process.stdout.write(envelope(result.status, result.changed, true, result, result.error));
   process.exitCode = exitCode(result.status);
 }

package/lib/internal/task-ledger.ts

@@ -8,17 +8,18 @@ import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, stage-status\n`;
+const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, rework-intent-rebuild, stage-status\n`;
 const FLAGS: Record<string, string> = {
   '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
   '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
   '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation',
   '--intent-id': 'intentId', '--finding-id': 'findingId', '--source-artifact': 'sourceArtifact',
-  '--source-sha256': 'sourceSha256', '--target': 'target',
+  '--source-sha256': 'sourceSha256', '--classification': 'classification',
   '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
 const BOOLEAN = new Set(['needsImplementation']);
+const REWORK_CLASSIFICATIONS = new Set(['scope-or-requirement', 'design', 'implementation', 'human-decision', 'insufficient-evidence']);
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LEDGER_PAYLOAD_INVALID', message } })}\n`);
@@ -38,6 +39,7 @@ async function taskLedger(args: string[] = []): Promise<void> {
     internalHandlerRoute('task-ledger', 'decision-next-id', kind),
     internalHandlerRoute('task-ledger', 'decision-upsert', kind),
     internalHandlerRoute('task-ledger', 'rework-intent-upsert', kind),
+    internalHandlerRoute('task-ledger', 'rework-intent-rebuild', kind),
     internalHandlerRoute('task-ledger', 'stage-status', kind)
   ].some(Boolean)) {
     usageFailure(`unknown ledger intent '${kind}'`); return;
@@ -67,14 +69,16 @@ async function taskLedger(args: string[] = []): Promise<void> {
     'finding-review': ['id', 'status', 'evidence'],
     'decision-next-id': [],
     'decision-upsert': ['id', 'stage', 'artifact'],
-    'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'target'],
+    'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'classification'],
+    'rework-intent-rebuild': [],
     'stage-status': ['stage']
   };
   const optional: Record<string, string[]> = {
     'finding-review': ['needsImplementation'],
-    'decision-upsert': ['needsImplementation']
+    'decision-upsert': ['needsImplementation'],
+    'rework-intent-rebuild': ['findingId', 'sourceArtifact', 'sourceSha256', 'classification']
   };
-  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert'
+  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert' || kind === 'rework-intent-rebuild'
     ? []
     : ['overrideTicket', 'overrideTarget', 'overrideScope'];
   const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]!, ...(optional[kind] ?? []), ...overrideFields]);
@@ -84,6 +88,9 @@ async function taskLedger(args: string[] = []): Promise<void> {
   if (missing) { usageFailure(`${kind} requires '${missing}'`); return; }
   const dryRunConflict = overrideDryRunConflict(values);
   if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
+  if (values.classification !== undefined && !REWORK_CLASSIFICATIONS.has(String(values.classification))) {
+    usageFailure(`invalid rework classification '${values.classification}'`); return;
+  }
   if (kind === 'stage-status') {
     if (!isReviewStage(String(values.stage))) { usageFailure(`stage-status requires a valid review stage`); return; }
     const resolved = resolveTaskRef(taskRef);

package/lib/internal/task-lifecycle.ts

@@ -7,10 +7,10 @@ import {
 import { lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import type { TaskLifecycleResult } from '../task/lifecycle.ts';
-import type { LifecycleRecoveryResult } from '../task/lifecycle-recovery.ts';
+import type { AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult } from '../agent-clients/adapter.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --stage <stage> --round <round> --artifact <artifact> --reason <reason>\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);

package/lib/internal/task-operation-registry.ts

@@ -22,7 +22,7 @@ export type TaskOperationEffect = TaskViewAccessEffect;
 export type TaskRefSource = 'argv' | 'environment' | 'none' | 'delegated' | 'input';
 
 export type SandboxControlTransportDecision = Readonly<{
-  kind: 'direct-host' | 'broker-client' | 'fail-closed';
+  kind: 'direct-host' | 'sandbox-local' | 'broker-client' | 'fail-closed';
   reasonCode: string | null;
 }>;
 
@@ -125,6 +125,7 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'task-ledger', 'finding-review', 'task-bound', 'progress'),
     descriptor('internal', 'task-ledger', 'decision-upsert', 'task-bound', 'progress'),
     descriptor('internal', 'task-ledger', 'rework-intent-upsert', 'task-bound', 'progress'),
+    descriptor('internal', 'task-ledger', 'rework-intent-rebuild', 'task-bound', 'progress'),
     descriptor('internal', 'task-warning', 'list', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-warning', 'add', 'task-bound', 'progress'),
     descriptor('internal', 'task-warning', 'set-status', 'task-bound', 'progress'),
@@ -277,6 +278,7 @@ export function resolveTaskOperation(
 export function resolveDelegatedTaskOperation(args: readonly string[]): TaskOperationDescriptor | null {
   const [operation, ...rest] = args;
   if (operation !== 'client' || !rest[0]) return null;
+  if (rest[0] === 'task-orchestration') return null;
   return resolveTaskOperation('internal', rest[0], rest.slice(1));
 }
 
@@ -340,7 +342,7 @@ function taskMarkerState(env: NodeJS.ProcessEnv): TaskMarkerState {
 
 export function resolveSandboxControlTransport(
   env: NodeJS.ProcessEnv = process.env,
-  options: Readonly<{ statusMountPath?: string }> = {}
+  options: Readonly<{ statusMountPath?: string; localWorkflow?: boolean }> = {}
 ): SandboxControlTransportDecision {
   const hasAnyMarker = TASK_MARKER_KEYS.some((key) => Boolean(env[key]))
     || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING)
@@ -407,13 +409,15 @@ export function resolveSandboxControlTransport(
     if (!hasCompleteConfig) {
       return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
     }
-    return { kind: 'broker-client', reasonCode: null };
+    return { kind: options.localWorkflow ? 'sandbox-local' : 'broker-client', reasonCode: null };
   }
   if (!hasAnyMarker) return { kind: 'direct-host', reasonCode: null };
   if (!hasCompleteConfig || (taskBound && !runtime) || (!taskBound && runtime)) {
     return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
   }
-  return { kind: 'broker-client', reasonCode: null };
+  return options.localWorkflow
+    ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_MISSING' }
+    : { kind: 'broker-client', reasonCode: null };
 }
 
 export function hasTaskBoundMarker(env: NodeJS.ProcessEnv = process.env): boolean {

package/lib/platform/completion-backfill.ts

@@ -19,6 +19,24 @@ type CompletionBackfillResult = PlatformResult & {
   artifacts: Array<{ artifact: string; status: PlatformResult['status'] }>;
   warnings: Array<{ id: string; status: string }>;
 };
+type CompletionBackfillEligibility = Readonly<{
+  status: 'ready' | 'failed';
+  eligible: boolean;
+  error: { code: string; message: string; retryable: boolean } | null;
+}>;
+type BackfillArtifactReference = Readonly<
+  | { status: 'ignored'; artifact: null; error: null }
+  | { status: 'ready'; artifact: string; error: null }
+  | { status: 'failed'; artifact: null; error: { code: string; message: string; retryable: false } }
+>;
+type BackfillWarningMatch = Readonly<{
+  warning: ReturnType<typeof getOpenWorkflowWarnings>[number];
+  artifact: string;
+}>;
+type BackfillWarningMatches = Readonly<
+  | { status: 'ready'; matches: BackfillWarningMatch[]; error: null }
+  | { status: 'failed'; matches: []; error: { code: string; message: string; retryable: false } }
+>;
 
 function result(
   base: PlatformResult,
@@ -28,18 +46,65 @@ function result(
   return { ...base, artifacts, warnings };
 }
 
-function excludedPrReview(taskDir: string, message: string): string | null {
-  const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])(pr-review(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
+function referencedBackfillArtifact(taskDir: string, message: string): BackfillArtifactReference {
+  const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])([a-z][a-z-]*(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
     .map((match) => match[1]!);
-  if (names.length !== 1) return null;
+  if (names.length !== 1) return { status: 'ignored', artifact: null, error: null };
   const parsed = parseArtifactName(names[0]!);
-  if (!parsed || parsed.family !== 'pr-review') return null;
+  if (!parsed || (parsed.family !== 'pr-review' && !COMPLETION_BACKFILL_FAMILIES.includes(parsed.family as typeof COMPLETION_BACKFILL_FAMILIES[number]))) {
+    return { status: 'ignored', artifact: null, error: null };
+  }
   const artifactPath = path.join(taskDir, parsed.name);
   try {
     const stat = fs.lstatSync(artifactPath);
-    return stat.isFile() && !stat.isSymbolicLink() ? parsed.name : null;
-  } catch {
-    return null;
+    if (stat.isSymbolicLink()) return {
+      status: 'failed', artifact: null,
+      error: { code: 'ARTIFACT_TOPOLOGY_CONFLICT', message: `SYMBOLIC_LINK: symbolic links are not workflow artifacts: ${parsed.name}`, retryable: false }
+    };
+    if (!stat.isFile()) return {
+      status: 'failed', artifact: null,
+      error: { code: 'ARTIFACT_TOPOLOGY_CONFLICT', message: `NON_REGULAR_FILE: artifact is not a regular file: ${parsed.name}`, retryable: false }
+    };
+    fs.accessSync(artifactPath, fs.constants.R_OK);
+    return { status: 'ready', artifact: parsed.name, error: null };
+  } catch (error) {
+    return {
+      status: 'failed', artifact: null,
+      error: { code: 'ARTIFACT_READ_FAILED', message: `Unable to inspect referenced artifact '${parsed.name}': ${error instanceof Error ? error.message : String(error)}`, retryable: false }
+    };
+  }
+}
+
+function matchingBackfillWarnings(taskDir: string, content: string): BackfillWarningMatches {
+  const matches: BackfillWarningMatch[] = [];
+  for (const warning of getOpenWorkflowWarnings(content)) {
+    if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact') continue;
+    const reference = referencedBackfillArtifact(taskDir, warning.message);
+    if (reference.status === 'failed') return { status: 'failed', matches: [], error: reference.error };
+    if (reference.status === 'ready') matches.push({ warning, artifact: reference.artifact });
+  }
+  return { status: 'ready', matches, error: null };
+}
+
+function inspectCompletionBackfillEligibility(
+  taskRef: string,
+  options: Pick<CompletionBackfillOptions, 'cwd'> = {}
+): CompletionBackfillEligibility {
+  const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+  if (!resolved.ok) return {
+    status: 'failed', eligible: false,
+    error: { code: resolved.code, message: resolved.message, retryable: false }
+  };
+  try {
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const matching = matchingBackfillWarnings(resolved.taskDir, content);
+    if (matching.status === 'failed') return { status: 'failed', eligible: false, error: matching.error };
+    return { status: 'ready', eligible: matching.matches.length > 0, error: null };
+  } catch (error) {
+    return {
+      status: 'failed', eligible: false,
+      error: { code: 'TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false }
+    };
   }
 }
 
@@ -60,6 +125,8 @@ async function backfillCompletionComments(
     }
   }), [], []);
   const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const matching = matchingBackfillWarnings(resolved.taskDir, initialContent);
+  if (matching.status === 'failed') return result(platformResult('failed', { error: matching.error }), [], []);
   const issueIdentity = taskIssueIdentity(parseTaskFrontmatter(initialContent));
   if (!issueIdentity) return result(platformResult('no-op', {
     error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false }
@@ -92,17 +159,12 @@ async function backfillCompletionComments(
     }), artifacts, []);
   }
 
-  const matching = getOpenWorkflowWarnings(initialContent).flatMap((warning) => {
-    if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact') return [];
-    const excluded = excludedPrReview(resolved.taskDir, warning.message);
-    return excluded ? [{ warning, excluded }] : [];
-  });
   const warnings: CompletionBackfillResult['warnings'] = [];
   let metadata: ReturnType<typeof captureTaskWriteMetadata> | null = null;
-  for (const { warning, excluded } of matching) {
+  for (const { warning, artifact } of matching.matches) {
     metadata ??= captureTaskWriteMetadata();
     const resolution = [
-      `excluded=${excluded}`,
+      `artifact=${artifact}`,
       `completionFamilies=${COMPLETION_BACKFILL_FAMILIES.join(',')}`,
       `synchronized=${inventory.artifacts.map((artifact) => artifact.name).join(',') || 'none'}`,
       `completedAt=${metadata.timestamp}`
@@ -131,5 +193,5 @@ async function backfillCompletionComments(
   }), artifacts, warnings);
 }
 
-export { backfillCompletionComments };
-export type { CompletionBackfillOptions, CompletionBackfillResult };
+export { backfillCompletionComments, inspectCompletionBackfillEligibility };
+export type { CompletionBackfillEligibility, CompletionBackfillOptions, CompletionBackfillResult };

package/lib/platform/issue-comments.ts

@@ -27,7 +27,6 @@ import {
 import { projectTaskComment } from './task-comment-projection.ts';
 import {
   canonicalizeCommentBody,
-  canonicalizeSummaryBody,
   escapeHtmlText,
   fenceRanges,
   renderSafeCodeFence
@@ -52,7 +51,6 @@ type SyncOptions = {
   client?: PlatformClient;
   runtimeVersion?: string;
   summaryAuthorization?: { sha256: string };
-  verifyOnly?: boolean;
 };
 
 function providerCommentId(id: string, provider: { identity?: { comment?: string } }): number | string {
@@ -76,8 +74,6 @@ const ARTIFACT_TITLES: Record<string, string> = {
   'review-plan': '技术方案审查',
   code: '实现报告',
   'review-code': '代码审查',
-  'manual-validation': '人工验证报告',
-  'validation-run': '验证运行证据',
   'pr-review': 'PR 审查报告'
 };
 
@@ -154,7 +150,7 @@ function taskCommentLanguage(repoRoot: string): string {
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
   const stem = path.basename(artifact, '.md');
-  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r(\d+))?$/);
+  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|pr-review)(?:-r(\d+))?$/);
   if (!match) throw new Error(`unsupported artifact '${artifact}'`);
   const base = ARTIFACT_TITLES[match[1]!]!;
   const round = match[2] ? Number(match[2]) : 1;
@@ -483,15 +479,6 @@ function summaryPosition(comments: RemoteComment[], taskId: string): { ok: boole
   return { ok: managed.every((comment) => sequence >= comment.createdSequence!), known: true, summary: summary[0]! };
 }
 
-function summaryDigest(comment: RemoteComment): string {
-  const body = normalizeCommentContent(comment.body)
-    .replace(/^<!-- sync-issue:[^\n]+:summary -->\n## [^\n]+\n\n> [^\n]+\n\n/u, '')
-    .replace(/^<details><summary>恢复元数据<\/summary>[\s\S]*?<\/details>\n\n/u, '')
-    .replace(/\n---\n\*[^\n]*\*$/u, '');
-  const canonical = canonicalizeSummaryBody(body);
-  return canonical.ok ? createHash('sha256').update(canonical.value).digest('hex') : '';
-}
-
 async function listedComments(provider: any, loaded: any, parent: ReturnType<typeof taskIssueIdentity>): Promise<any> {
   return provider.comments?.list
     ? provider.comments.list({ context: providerOperationContext(loaded), parent }).then((response: any) => response.ok
@@ -609,27 +596,6 @@ async function syncPlatformComment(taskRef: string, options: SyncOptions): Promi
     }
   }
 
-  if (options.verifyOnly) {
-    if (options.kind !== 'summary' || !options.summaryAuthorization) {
-      return platformResult('failed', {
-        ...contextFields(context), resource: { kind: 'issue', number: issue },
-        error: { code: 'SUMMARY_VERIFICATION_INVALID', message: 'summary verification requires durable authorization', retryable: false }
-      });
-    }
-    const position = summaryPosition(listed.value, resolved.taskId);
-    if (!position.ok || !position.summary || summaryDigest(position.summary) !== options.summaryAuthorization.sha256) {
-      return platformResult('failed', {
-        ...contextFields(context), resource: { kind: 'issue', number: issue },
-        error: { code: 'SUMMARY_VERIFICATION_FAILED', message: 'summary marker, body digest, or managed comment order is invalid', retryable: true }
-      });
-    }
-    return platformResult('no-op', {
-      ...contextFields(context), changed: false, resource: { kind: 'issue', number: issue },
-      comment: { kind: options.kind, marker: desired[0]!.marker, ids: [position.summary.id], parts: 1 }, error: null
-    });
-  }
-
-
   // Backfill only supplies missing artifact comments; valid existing marker sets stay untouched.
   if (options.kind === 'artifact' && options.backfill && existing.length > 0) {
     const operations = existing.map((comment): PlatformOperation => ({

package/lib/platform/pr-summary.ts

@@ -35,7 +35,7 @@ import type {
   MechanicalChangeReport,
   PrChangeReport
 } from './pr-change-report.ts';
-import { manualValidationFinalSummaryProjectionMatches } from '../task/manual-validation-receipt.ts';
+import { MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, manualValidationFinalSummaryProjectionMatches } from '../task/manual-validation-receipt.ts';
 import { readManualValidationCompletion } from '../task/manual-validation-completion.ts';
 
 type SummaryComment = { id: number | string; body: string };
@@ -582,6 +582,7 @@ async function syncPullRequestSummary(
       const initial = await inspectBoundPullRequest(context, resolved.repoRoot, prIdentity, loaded.value);
       if (!initial.ok) return fail(initial.status, context, initial.error);
       const manual = options.manualValidation;
+      let manualEvidenceDigest: string | null = null;
       const hasFinalManualValidation = /###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)/u.test(options.body);
       if (hasFinalManualValidation && (!manual || manual.phase !== 'final')) return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'final manual-validation summary requires the transaction coordinator', retryable: false }, prNumber);
       if (manual && (manual.phase === 'pending' ? hasFinalManualValidation : !hasFinalManualValidation)) return fail('failed', context, { code: 'MANUAL_VALIDATION_SUMMARY_PHASE_INVALID', message: 'manual-validation summary phase does not match the requested writer phase', retryable: false }, prNumber);
@@ -599,6 +600,7 @@ async function syncPullRequestSummary(
           });
           if (!completion.ok) return fail('failed', context, platformError(completion.error), prNumber);
           const { receipt, transaction } = completion.value;
+          manualEvidenceDigest = receipt.evidenceDigest;
           if (transaction.phase !== 'final-promotion-in-progress' || !transaction.eventAppended) return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_PHASE_INVALID', message: 'final summary requires a receipt-backed promotion intent', retryable: false }, prNumber);
           if (!manualValidationFinalSummaryProjectionMatches(options.body, receipt)) return fail('failed', context, { code: 'MANUAL_VALIDATION_SUMMARY_PROJECTION_INVALID', message: 'final summary body does not match the canonical receipt projection', retryable: false }, prNumber);
         }
@@ -635,7 +637,13 @@ async function syncPullRequestSummary(
       }
       const replaced = replaceCanonicalReportPlaceholder(`${prefix.value}${placeholder}${suffix.value}`, report.value);
       if (!replaced.ok) return fail('failed', context, platformError(replaced.error));
-      const desired = buildPullRequestSummary(resolved.taskId, replaced.value, initial.value.head.sha, renderHumanOverrideAudit(taskContent));
+      const renderedBody = manual?.phase === 'final'
+        ? replaced.value.replace(
+          MANUAL_VALIDATION_RECEIPT_PLACEHOLDER,
+          `<!-- manual-validation-receipt: transaction=${manual.transactionId}; receipt=${manual.receiptDigest}; evidence=${manualEvidenceDigest}; head=${manual.prHeadSha} -->`
+        )
+        : replaced.value;
+      const desired = buildPullRequestSummary(resolved.taskId, renderedBody, initial.value.head.sha, renderHumanOverrideAudit(taskContent));
       if (!isSafeSummaryEnvelope(desired, resolved.taskId)) return fail('failed', context, {
         code: 'PR_SUMMARY_RENDER_INVALID',
         message: 'Summary contains an invalid or duplicated reserved control marker',

package/lib/sandbox/control/client.ts

@@ -11,10 +11,8 @@ import {
   type SandboxControlRequest,
   type SandboxControlResponse,
   type SandboxTaskCreateRequest,
-  type SandboxTaskCommandRequest,
   type SandboxTaskFinalizationRequest,
-  type SandboxCodexControllerRequest,
-  type SandboxTaskWorkflowRequest
+  type SandboxCodexControllerRequest
 } from './protocol.ts';
 import type {
   CodexControllerLeaseProofV1,
@@ -26,8 +24,6 @@ import { readSandboxControlPayload, readSandboxControlStatus } from './state.ts'
 import type { TaskCreateCandidateV1 } from '../../task/create.ts';
 import { accessSandboxTaskView, taskViewFromStatus, type TaskViewAccessEffect } from './task-view.ts';
 import { readSandboxControlIdentitySentinel } from './identity-sentinel.ts';
-import type { TaskWorkflowRequest } from './task-workflow.ts';
-import type { LifecycleAuthorityRequestV1 } from '../../task/control-authority.ts';
 import { configuredShortIdLength, resolveShortIdReadOnly } from '../../task/short-id.ts';
 
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
@@ -119,8 +115,6 @@ function preflight(
 
 function taskViewEffectForRequest(request: SandboxControlRequest): TaskViewAccessEffect | null {
   if (request.family === 'task-lifecycle' || request.family === 'task-finalization') return 'progress';
-  if (request.family === 'task-orchestration') return request.args[1] === 'status' ? 'diagnostic' : 'progress';
-  if (request.family === 'task-workflow') return request.workflow.operation === 'artifact-inspect' || request.workflow.operation === 'decision-next-id' ? 'diagnostic' : 'progress';
   return null;
 }
 
@@ -194,9 +188,7 @@ export function resolveVisibleActiveShortId(ref: string): string | null {
 // may be a documented short id. Compare canonical ids so a bound sandbox keeps
 // refusing other tasks without rejecting its own task's short id.
 function canonicalRequestTask(request: SandboxControlRequest): CanonicalRequestTask {
-  const ref = request.family === 'task-workflow'
-    ? request.workflow.taskId
-    : 'args' in request ? request.args[0] ?? null : null;
+  const ref = 'args' in request ? request.args[0] ?? null : null;
   if (!ref) return { kind: 'none' };
   if (CONTROL_TASK_ID_RE.test(ref)) return { kind: 'task', taskId: ref };
   if (!CONTROL_SHORT_ID_RE.test(ref)) return { kind: 'none' };
@@ -223,7 +215,7 @@ function exchangeSandboxControl(request: SandboxControlRequest, params: Readonly
         || (requestTask.kind === 'task' && requestTask.taskId !== identity.taskId))) {
       clientError('SANDBOX_CONTROL_IDENTITY_TOPOLOGY_MISMATCH', 'request task does not match the sandbox identity', false);
     }
-    if (identity.mode === 'branch-only' && (request.family === 'task-finalization' || request.family === 'task-workflow')) {
+    if (identity.mode === 'branch-only' && request.family === 'task-finalization') {
       clientError('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks', false);
     }
   }
@@ -384,7 +376,7 @@ export function requestSandboxControl(params: Readonly<{
   token?: string; generation?: string; timeoutMs?: number;
 }>): SandboxControlResponse {
   if (!isSandboxControlFamily(params.family)) clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' is not allowed`, false);
-  if (params.family === 'task-create' || params.family === 'codex-controller' || params.family === 'task-finalization' || params.family === 'task-workflow') {
+  if (params.family === 'task-create' || params.family === 'codex-controller' || params.family === 'task-finalization') {
     clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, false);
   }
   const auth = authority(params);
@@ -392,41 +384,13 @@ export function requestSandboxControl(params: Readonly<{
   const request: SandboxControlRequest = {
     version: 3, id: randomUUID(), ...auth, issuedAt,
     expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: params.family as 'task-lifecycle' | 'task-orchestration', args: params.args,
+    family: params.family as 'task-lifecycle', args: params.args,
     controllerProcess: null,
     controllerProof: null
   };
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxTaskControl(params: Readonly<{
-  family: 'task-lifecycle' | 'task-orchestration';
-  args: string[];
-  controllerProof: CodexControllerLeaseProofV1 | null;
-  authority?: LifecycleAuthorityRequestV1;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-}>): SandboxControlResponse {
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const request: SandboxTaskCommandRequest = {
-    version: 3,
-    id: params.authority?.requestId ?? randomUUID(),
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: params.family,
-    args: params.args,
-    controllerProcess: null,
-    controllerProof: params.authority ? null : params.controllerProof,
-    ...(params.authority ? { authority: params.authority } : {})
-  };
-  return exchangeSandboxControl(request, params);
-}
-
 export function requestSandboxTaskFinalization(params: Readonly<{
   agent: string;
   channelDir?: string;
@@ -455,33 +419,6 @@ export function requestSandboxTaskFinalization(params: Readonly<{
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxTaskWorkflow(params: Readonly<{
-  workflow: TaskWorkflowRequest;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-  authority?: LifecycleAuthorityRequestV1;
-}>): SandboxControlResponse {
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const request: SandboxTaskWorkflowRequest = {
-    version: 3,
-    id: params.workflow.id,
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: 'task-workflow',
-    args: [],
-    controllerProcess: null,
-    controllerProof: null,
-    workflow: params.workflow,
-    ...(params.authority ? { authority: params.authority } : {})
-  };
-  return exchangeSandboxControl(request, params);
-}
-
 type CodexControllerClosed = Readonly<{
   version: 1;
   status: 'closed';