@fitlab-ai/agent-infra 0.10.0 → 0.11.1

package/dist/lib/task/workflow-dispatch.js

@@ -0,0 +1,161 @@
+import { reconcileTaskInvalidation } from './invalidation-command.js';
+import { applyLedgerIntent } from './ledger-intents.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
+import { applyWorkflowWarningIntent } from './workflow-warning-intents.js';
+function failed(code, message) {
+    return { status: 'failed', changed: false, error: { code, message } };
+}
+function isFailure(value) {
+    return Boolean(value) && typeof value === 'object' && value.status === 'failed';
+}
+function options(args, allowed) {
+    const values = {};
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--dry-run') {
+            if (!Object.hasOwn(allowed, flag) || values[flag] !== undefined)
+                return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `invalid option '${flag}'`);
+            values[flag] = true;
+            continue;
+        }
+        const key = allowed[flag];
+        if (!key || values[flag] !== undefined)
+            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `invalid option '${flag}'`);
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', `option '${flag}' requires a value`);
+        if (flag === '--needs-implementation' && value !== 'true' && value !== 'false') {
+            return failed('TASK_WORKFLOW_PAYLOAD_INVALID', "option '--needs-implementation' must be true or false");
+        }
+        values[flag] = value;
+    }
+    return values;
+}
+function value(values, flag) {
+    const candidate = values[flag];
+    return typeof candidate === 'string' ? candidate : undefined;
+}
+function required(values, flags) {
+    const missing = flags.find((flag) => value(values, flag) === undefined);
+    return missing ? failed('TASK_WORKFLOW_PAYLOAD_INVALID', `option '${missing}' is required`) : null;
+}
+function resultForLock(error) {
+    if (error instanceof TaskExecutionLockError)
+        return failed(error.code, error.message);
+    throw error;
+}
+function ledgerIntent(operation, args) {
+    const [taskRef, kind] = args;
+    const mappings = {
+        'ledger-finding-response': {
+            kind: 'finding-respond', required: ['--id', '--round', '--status', '--evidence'],
+            flags: { '--id': 'id', '--round': 'round', '--status': 'status', '--evidence': 'evidence', '--dry-run': 'dryRun' }
+        },
+        'ledger-finding-review': {
+            kind: 'finding-review', required: ['--id', '--status', '--evidence'],
+            flags: { '--id': 'id', '--status': 'status', '--evidence': 'evidence', '--needs-implementation': 'needsImplementation', '--dry-run': 'dryRun' }
+        },
+        'ledger-finding-upsert': {
+            kind: 'finding-upsert', required: ['--stage', '--review-artifact', '--ordinal', '--severity', '--evidence'],
+            flags: { '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal', '--severity': 'severity', '--evidence': 'evidence', '--dry-run': 'dryRun' }
+        },
+        'decision-next-id': { kind: 'decision-next-id', required: [], flags: {} },
+        'decision-upsert': {
+            kind: 'decision-upsert', required: ['--id', '--stage', '--artifact'],
+            flags: { '--id': 'id', '--stage': 'stage', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation', '--dry-run': 'dryRun' }
+        }
+    };
+    const mapping = mappings[operation];
+    if (!mapping || !taskRef || kind === undefined)
+        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task workflow ledger request is invalid');
+    const values = options(args, mapping.flags);
+    if (isFailure(values))
+        return values;
+    const missing = required(values, mapping.required);
+    if (missing)
+        return missing;
+    const dryRun = values['--dry-run'] === true;
+    if (mapping.kind === 'decision-next-id')
+        return { kind: mapping.kind, taskRef };
+    if (mapping.kind === 'finding-respond')
+        return {
+            kind: mapping.kind, taskRef, id: value(values, '--id'), round: Number(value(values, '--round')),
+            status: value(values, '--status'), evidence: value(values, '--evidence'), ...(dryRun ? { dryRun } : {})
+        };
+    if (mapping.kind === 'finding-review')
+        return {
+            kind: mapping.kind, taskRef, id: value(values, '--id'), status: value(values, '--status'),
+            evidence: value(values, '--evidence'), ...(value(values, '--needs-implementation') === 'true' ? { needsImplementation: true } : {}),
+            ...(dryRun ? { dryRun } : {})
+        };
+    if (mapping.kind === 'finding-upsert')
+        return {
+            kind: mapping.kind, taskRef, stage: value(values, '--stage'), reviewArtifact: value(values, '--review-artifact'),
+            ordinal: Number(value(values, '--ordinal')), severity: value(values, '--severity'), evidence: value(values, '--evidence'),
+            ...(dryRun ? { dryRun } : {})
+        };
+    return {
+        kind: mapping.kind, taskRef, id: value(values, '--id'), stage: value(values, '--stage'),
+        artifact: value(values, '--artifact'), ...(value(values, '--needs-implementation') === 'true' ? { needsImplementation: true } : {}),
+        ...(dryRun ? { dryRun } : {})
+    };
+}
+function warningIntent(args) {
+    const [taskRef, kind] = args;
+    if (!taskRef || kind !== 'add')
+        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task workflow warning request is invalid');
+    const values = options(args, {
+        '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
+        '--message': 'message', '--action': 'action', '--dry-run': 'dryRun'
+    });
+    if (isFailure(values))
+        return values;
+    const missing = required(values, ['--step', '--severity', '--code', '--target', '--message', '--action']);
+    if (missing)
+        return missing;
+    return {
+        kind: 'add', taskRef, step: value(values, '--step'), severity: value(values, '--severity'),
+        code: value(values, '--code'), target: value(values, '--target'), message: value(values, '--message'),
+        action: value(values, '--action'), ...(values['--dry-run'] === true ? { dryRun: true } : {})
+    };
+}
+/**
+ * The caller has already selected and authorized the execution boundary.
+ * This function deliberately invokes task domains in that process: starting a
+ * second CLI process would discard the broker binding and could misclassify a
+ * sandbox process with cleared environment variables as direct-host.
+ */
+export function dispatchWorkflowCommand(repoRoot, operation, args) {
+    const taskRef = args[0];
+    if (!taskRef)
+        return failed('TASK_WORKFLOW_PAYLOAD_INVALID', 'task ref is required');
+    try {
+        if (operation === 'invalidation-reconcile') {
+            const values = options(args, { '--max-targets': 'maxTargets', '--dry-run': 'dryRun' });
+            if (isFailure(values))
+                return values;
+            const maxTargets = value(values, '--max-targets');
+            if (maxTargets !== undefined && (!Number.isSafeInteger(Number(maxTargets)) || Number(maxTargets) < 1)) {
+                return failed('TASK_WORKFLOW_PAYLOAD_INVALID', '--max-targets must be a positive integer');
+            }
+            return withTaskExecutionLock(repoRoot, taskRef, 'task-invalidation.reconcile', () => reconcileTaskInvalidation(taskRef, {
+                repoRoot, ...(maxTargets === undefined ? {} : { maxTargets: Number(maxTargets) }),
+                ...(values['--dry-run'] === true ? { dryRun: true } : {})
+            }));
+        }
+        if (operation === 'warning-add') {
+            const intent = warningIntent(args);
+            if (isFailure(intent))
+                return intent;
+            return withTaskExecutionLock(repoRoot, taskRef, 'task-warning.add', () => applyWorkflowWarningIntent(intent, { repoRoot }));
+        }
+        const intent = ledgerIntent(operation, args);
+        if (isFailure(intent))
+            return intent;
+        return withTaskExecutionLock(repoRoot, taskRef, `task-ledger.${intent.kind}`, () => applyLedgerIntent(intent, { repoRoot }));
+    }
+    catch (error) {
+        return resultForLock(error);
+    }
+}
+//# sourceMappingURL=workflow-dispatch.js.map

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.10.0",
-  "sourceInputHash": "d7af8de4bd6c1996a920335dfc766e23b8d391cd4db2965d7d9dfaa2cb112059",
-  "internalExecutableBuildHash": "63a6d2d9113dd353dfce165efccf82a5ea25398c2aad9f1b2c5543dc28e8b833"
+  "packageVersion": "0.11.1",
+  "sourceInputHash": "0d66fb32bbdc0982d38a04b86b0278768bb6091eb945ebd90a432f9bae363712",
+  "internalExecutableBuildHash": "4b1edd20ed87d3d742e5e7975fd49b1ac1fb0ff14f837d52ee9ba3ab11318365"
 }

package/lib/internal/cli-route-inventory.ts

@@ -36,7 +36,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-create': ['input'],
   'task-qualification': ['proposal', 'confirm', 'supersede', 'revoke'],
   'sandbox-control': ['serve', 'execute', 'recover', 'client'],
-  'host-control': ['serve', 'status', 'install', 'uninstall'],
   'agent-client': ['next-steps', 'model-selection'],
   'codex-lifecycle': ['preflight', 'capability-arm', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
   'codex-sandbox-controller': ['verify-context', 'run'],
@@ -47,7 +46,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'platform-security': ['read', 'dismiss'],
   'platform-metadata': ['init-labels', 'init-milestones'],
   'platform-context': ['resolve'],
-  'platform-comment': ['list', 'owner', 'backfill', 'sync'],
+  'platform-comment': ['list', 'recover', 'owner', 'backfill', 'sync'],
   'platform-issue': ['inspect', 'create', 'bind', 'sync'],
   'platform-pr': ['inspect', 'summary-context', 'resolve-external', 'create', 'bind', 'skip', 'sync', 'change-report', 'summary-sync', 'sync-in-labels'],
   'platform-pr-review': ['inspect', 'list', 'publish-pr', 'publish-task'],
@@ -57,9 +56,9 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert'],
   'task-warning': ['list', 'add', 'set-status'],
   'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
-  'task-artifact': ['inspect', 'init', 'finalize-local'],
+  'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],
   'task-orchestration': ['status', 'progress'],
-  'task-review': ['finalize-summary'],
+  'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
   'task-invalidation': ['reconcile'],
   'task-override': ['diagnose', 'issue', 'consume'],

package/lib/internal/manual-validation.ts

@@ -44,6 +44,7 @@ function printFailure(format: OutputFormat, error: { code: string; message: stri
 }
 
 const MANUAL_VALIDATION_STATUS_SECTION = /^###\s+(?:⚠️\s+(?:需人工校验|Manual Validation Required)|✅\s+(?:人工验证已通过|无需人工校验|Manual Validation Passed|No Manual Validation Required)|⏳\s+(?:人工验证待收尾|Manual Validation Pending))\s*$[\s\S]*?(?=^#{1,3}\s|(?![\s\S]))/gmu;
+const TRAILING_CANONICAL_REPORT_PLACEHOLDER = /\n*<!--\s*canonical-pr-change-report\s*-->\s*$/u;
 
 function manualSummaryBody(body: string, phase: 'pending' | 'final', transactionId: string, receiptDigest = '', evidenceDigest = '', prHeadSha = ''): string {
   const chinese = /###\s+(?:⚠️\s+需人工校验|✅\s+(?:人工验证已通过|无需人工校验)|⏳\s+人工验证待收尾)\s*$/mu.test(body);
@@ -55,10 +56,13 @@ function manualSummaryBody(body: string, phase: 'pending' | 'final', transaction
       ? `### ✅ 人工验证已通过\n\n人工验证已通过；transaction=${transactionId}; receipt=${receiptDigest}; evidence=${evidenceDigest}; head=${prHeadSha}.`
       : `### ✅ Manual Validation Passed\n\nManual validation passed; transaction=${transactionId}; receipt=${receiptDigest}; evidence=${evidenceDigest}; head=${prHeadSha}.`;
   let inserted = false;
-  const updated = body.replace(MANUAL_VALIDATION_STATUS_SECTION, () => {
+  const updated = body.replace(MANUAL_VALIDATION_STATUS_SECTION, (matched) => {
     if (inserted) return '';
     inserted = true;
-    return `${section}\n\n`;
+    const trailingPlaceholder = TRAILING_CANONICAL_REPORT_PLACEHOLDER.exec(matched)?.[0];
+    return trailingPlaceholder
+      ? `${trailingPlaceholder.trim()}\n\n${section}\n\n`
+      : `${section}\n\n`;
   });
   return inserted ? `${updated.replace(/\s+$/u, '')}\n` : `${body.replace(/\s+$/u, '')}\n\n${section}\n`;
 }

package/lib/internal/platform-comment.ts

@@ -9,10 +9,12 @@ import {
 } from '../platform/issue-comments.ts';
 import type { CommentKind } from '../platform/issue-comments.ts';
 import type { PlatformResult } from '../platform/types.ts';
+import { recoverTaskFromComments } from '../platform/task-recovery.ts';
 import { backfillCompletionComments } from '../platform/completion-backfill.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal platform-comment list --issue <token> [--cwd <path>]
+       agent-infra-internal platform-comment recover --issue <token> --task-id <TASK-id> --output <staging-task.md> [--cwd <path>]
        agent-infra-internal platform-comment owner <task-ref> [--cwd <path>]
        agent-infra-internal platform-comment backfill <task-ref> --agent <agent> [--cwd <path>]
        agent-infra-internal platform-comment sync <task-ref> --kind <kind> --agent <agent> [--artifact <file>] [--body-file <path|->] [--status-label <label>] [--backfill] [--cwd <path>]
@@ -35,7 +37,7 @@ function parseFlags(args: string[], start: number): { values: Record<string, str
   const seen = new Set<string>();
   for (let index = start; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (!['--issue', '--cwd', '--kind', '--agent', '--artifact', '--body-file', '--status-label', '--backfill'].includes(flag)) {
+    if (!['--issue', '--task-id', '--output', '--cwd', '--kind', '--agent', '--artifact', '--body-file', '--status-label', '--backfill'].includes(flag)) {
       return { values, error: `unknown option '${flag}'` };
     }
     if (seen.has(flag)) return { values, error: `duplicate option '${flag}'` };
@@ -59,11 +61,12 @@ async function platformComment(args: string[] = []): Promise<void> {
   const operation = args[0];
   if (!operation || ![
     internalHandlerRoute('platform-comment', 'list', operation),
+    internalHandlerRoute('platform-comment', 'recover', operation),
     internalHandlerRoute('platform-comment', 'owner', operation),
     internalHandlerRoute('platform-comment', 'backfill', operation),
     internalHandlerRoute('platform-comment', 'sync', operation)
   ].some(Boolean)) { fail('a valid operation is required'); return; }
-  const hasTaskRef = operation !== 'list';
+  const hasTaskRef = operation !== 'list' && operation !== 'recover';
   const taskRef = hasTaskRef ? args[1] : undefined;
   if (hasTaskRef && (!taskRef || taskRef.startsWith('--'))) { fail(`${operation} requires a task ref`); return; }
   const parsed = parseFlags(args, hasTaskRef ? 2 : 1);
@@ -77,6 +80,54 @@ async function platformComment(args: string[] = []): Promise<void> {
     finish(await listPlatformComments(issue, cwd));
     return;
   }
+  if (internalHandlerRoute('platform-comment', 'recover', operation)) {
+    const issue = parsed.values.issue;
+    const taskId = parsed.values.taskId;
+    const output = parsed.values.output;
+    if (typeof issue !== 'string' || !issue || typeof taskId !== 'string' || !/^TASK-\d{8}-\d{6}$/.test(taskId)
+      || typeof output !== 'string' || !output) {
+      fail('recover requires --issue <token> --task-id <TASK-id> --output <staging-task.md>');
+      return;
+    }
+    const unexpected = Object.keys(parsed.values).find((key) => !['issue', 'taskId', 'output', 'cwd'].includes(key));
+    if (unexpected) { fail(`recover does not accept '--${unexpected}'`); return; }
+    const outputPath = path.resolve(cwd, output);
+    const workspaceDir = path.resolve(cwd, '.agents', 'workspace');
+    const stagingDir = path.dirname(outputPath);
+    const stagingParent = fs.existsSync(stagingDir) ? path.dirname(fs.realpathSync(stagingDir)) : '';
+    const realWorkspace = fs.existsSync(workspaceDir) ? fs.realpathSync(workspaceDir) : '';
+    if (path.basename(outputPath) !== 'task.md' || stagingParent !== realWorkspace
+      || !path.basename(stagingDir).startsWith('.restore-staging-') || !fs.existsSync(stagingDir)
+      || !fs.lstatSync(stagingDir).isDirectory() || fs.existsSync(outputPath)) {
+      fail('recover output must be a new task.md inside an existing .agents/workspace/.restore-staging-* directory');
+      return;
+    }
+    const listed = await listPlatformComments(issue, cwd);
+    if (listed.status === 'failed' || listed.status === 'blocked' || !listed.comments) { finish(listed); return; }
+    try {
+      const taskContent = recoverTaskFromComments({ taskId, comments: listed.comments });
+      fs.writeFileSync(outputPath, taskContent, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+      finish({
+        ...listed,
+        status: 'applied',
+        changed: true,
+        operations: [{ name: `recovery:task:${taskId}`, status: 'applied', reasonCode: null }],
+        error: null
+      });
+    } catch (error) {
+      finish({
+        ...listed,
+        status: 'failed',
+        changed: false,
+        error: {
+          code: 'RECOVERY_EVIDENCE_MISSING',
+          message: error instanceof Error ? error.message : String(error),
+          retryable: false
+        }
+      });
+    }
+    return;
+  }
   if (internalHandlerRoute('platform-comment', 'owner', operation)) {
     const unexpected = Object.keys(parsed.values).find((key) => key !== 'cwd');
     if (unexpected) { fail(`owner does not accept '--${unexpected}'`); return; }

package/lib/internal/task-artifact.ts

@@ -1,7 +1,7 @@
 import { parseArtifactCommand, executeArtifactCommand } from '../task/artifact-command.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family>\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> finalize-local --family <analysis|plan|code> --artifact <artifact> [--recovery-id <id>]\n\nInspect, initialize, or finalize a workflow artifact without changing task state.\n`;
+const USAGE = `Usage: agent-infra-internal task-artifact <N | TASK-id> inspect --family <family>\n       agent-infra-internal task-artifact <N | TASK-id> init --family <family> --artifact <artifact> [--locale <zh-CN|en>]\n       agent-infra-internal task-artifact <N | TASK-id> preflight|finalize-local --family <analysis|plan|code> --artifact <artifact> [--recovery-id <id>]\n\nInspect, initialize, preflight, or finalize a workflow artifact without changing task state.\n`;
 
 
 function taskArtifact(args: string[] = []): void {

package/lib/internal/task-finalization.ts

@@ -38,8 +38,8 @@ function parseFailure(error: unknown): string {
 }
 
 async function taskFinalization(args: string[] = []): Promise<void> {
-  if (!ensureInternalHandlerRoute('task-finalization', args)) return;
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
+  if (!ensureInternalHandlerRoute('task-finalization', args)) return;
 
   let operation;
   try {

package/lib/internal/task-lifecycle.ts

@@ -24,8 +24,8 @@ function parseFailure(error: unknown): string {
 }
 
 async function taskLifecycle(args: string[] = []): Promise<void> {
-  if (!ensureInternalHandlerRoute('task-lifecycle', args)) return;
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
+  if (!ensureInternalHandlerRoute('task-lifecycle', args)) return;
 
   let operation;
   try {

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

@@ -56,10 +56,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'sandbox-control', 'execute', 'non-task', 'progress', 'none'),
     descriptor('internal', 'sandbox-control', 'recover', 'conditional', 'recovery', 'delegated'),
     descriptor('internal', 'sandbox-control', 'client', 'conditional', 'progress', 'delegated'),
-    descriptor('internal', 'host-control', 'serve', 'non-task', 'progress', 'none'),
-    descriptor('internal', 'host-control', 'status', 'non-task', 'diagnostic', 'none'),
-    descriptor('internal', 'host-control', 'install', 'non-task', 'progress', 'none'),
-    descriptor('internal', 'host-control', 'uninstall', 'non-task', 'progress', 'none'),
     descriptor('internal', 'agent-client', 'next-steps', 'non-task', 'diagnostic', 'none'),
     descriptor('internal', 'agent-client', 'model-selection', 'non-task', 'diagnostic', 'none'),
     descriptor('internal', 'codex-lifecycle', 'preflight', 'non-task', 'diagnostic', 'none'),
@@ -91,6 +87,7 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'platform-metadata', 'init-milestones', 'non-task', 'remote-write', 'none'),
     descriptor('internal', 'platform-context', 'resolve', 'non-task', 'diagnostic', 'none'),
     descriptor('internal', 'platform-comment', 'list', 'non-task', 'diagnostic', 'none'),
+    descriptor('internal', 'platform-comment', 'recover', 'non-task', 'recovery', 'none'),
     descriptor('internal', 'platform-comment', 'owner', 'task-bound', 'diagnostic'),
     descriptor('internal', 'platform-comment', 'backfill', 'task-bound', 'remote-write'),
     descriptor('internal', 'platform-comment', 'sync', 'task-bound', 'remote-write'),
@@ -136,9 +133,11 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'task-activity', 'pr-review-terminate', 'task-bound', 'progress'),
     descriptor('internal', 'task-artifact', 'inspect', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-artifact', 'init', 'task-bound', 'artifact-write'),
+    descriptor('internal', 'task-artifact', 'preflight', 'task-bound', 'artifact-write'),
     descriptor('internal', 'task-artifact', 'finalize-local', 'task-bound', 'artifact-write'),
     descriptor('internal', 'task-orchestration', 'status', 'task-bound', 'diagnostic'),
     descriptor('internal', 'task-orchestration', 'progress', 'task-bound', 'progress'),
+    descriptor('internal', 'task-review', 'preflight', 'task-bound', 'artifact-write'),
     descriptor('internal', 'task-review', 'finalize-summary', 'task-bound', 'progress'),
     descriptor('internal', 'task-event', 'event', 'task-bound', 'progress'),
     descriptor('internal', 'task-invalidation', 'reconcile', 'task-bound', 'progress'),
@@ -218,7 +217,7 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
 ]);
 
 export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
-  'task-create', 'task-qualification', 'sandbox-control', 'host-control', 'agent-client', 'codex-lifecycle', 'codex-sandbox-controller',
+  'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle', 'codex-sandbox-controller',
   'git-workflow', 'task-delivery', 'release-workflow', 'platform-release-notes', 'platform-security', 'platform-metadata', 'platform-context',
   'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
   'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
@@ -342,28 +341,39 @@ export function resolveSandboxControlTransport(
   env: NodeJS.ProcessEnv = process.env,
   options: Readonly<{ statusMountPath?: string }> = {}
 ): SandboxControlTransportDecision {
-  const configuredStatusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
-  const fixedStatusDir = options.statusMountPath
-    ?? SANDBOX_CONTROL_STATUS_MOUNT;
   const hasAnyMarker = TASK_MARKER_KEYS.some((key) => Boolean(env[key]))
     || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING)
     || Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
-  const fixedStatusProbe = !env.AGENT_INFRA_TEST_HOST_CONTROL_ENDPOINT && path.isAbsolute(fixedStatusDir)
+  const fixedStatusDir = options.statusMountPath
+    ?? SANDBOX_CONTROL_STATUS_MOUNT;
+  const fixedStatusProbe = path.isAbsolute(fixedStatusDir)
     ? nativeDirectoryProbe(fixedStatusDir) : 'absent';
   if (fixedStatusProbe === 'unknown') {
     return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
   }
   const fixedStatusMounted = fixedStatusProbe === 'present';
+  // A fixed status mount is installed only in a task-bound sandbox. Its
+  // presence is not mutable by the sandbox process, so marker removal must
+  // never make that process look like a direct host invocation.
+  if (!hasAnyMarker) {
+    return fixedStatusMounted
+      ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' }
+      : { kind: 'direct-host', reasonCode: null };
+  }
+  const hasCompleteConfig = TASK_CONTROL_CONFIG_KEYS.every((key) => Boolean(env[key]));
+  if (!hasCompleteConfig) {
+    return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
+  }
+  const configuredStatusDir = env.AGENT_INFRA_CONTROL_STATUS_DIR;
   const configuredStatusProbe = configuredStatusDir && path.isAbsolute(configuredStatusDir)
     ? nativeDirectoryProbe(configuredStatusDir) : 'absent';
   if (configuredStatusProbe === 'unknown') {
     return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_UNAVAILABLE' };
   }
-  const statusDir = configuredStatusDir && path.isAbsolute(configuredStatusDir) && configuredStatusProbe === 'present'
-    ? configuredStatusDir
+  const statusDir = configuredStatusDir && path.isAbsolute(configuredStatusDir)
+    ? configuredStatusProbe === 'present' ? configuredStatusDir : null
     : fixedStatusMounted ? fixedStatusDir : null;
   const statusMounted = statusDir !== null;
-  const hasCompleteConfig = TASK_CONTROL_CONFIG_KEYS.every((key) => Boolean(env[key]));
   if (env.AGENT_INFRA_EXECUTOR_MANIFEST || env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING) {
     return { kind: 'fail-closed', reasonCode: 'TASK_CONTROL_TRANSPORT_INVALID' };
   }

package/lib/internal/task-orchestration.ts

@@ -20,11 +20,11 @@ function parseFailure(error: unknown): string {
 }
 
 async function taskOrchestration(args: string[] = []): Promise<void> {
-  if (!ensureInternalHandlerRoute('task-orchestration', args)) return;
   if (args[0] === '--help' || args[0] === '-h') {
     process.stdout.write(USAGE);
     return;
   }
+  if (!ensureInternalHandlerRoute('task-orchestration', args)) return;
 
   const route = internalHandlerRoute('task-orchestration', 'status', args[1] ?? '')
     ? 'status'

package/lib/internal/task-review.ts

@@ -1,17 +1,17 @@
 import { parseReviewCommand } from '../task/review-command.ts';
-import { finalizeReviewSummary } from '../task/review-finalization.ts';
+import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.ts';
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--recovery-id <id>] [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--recovery-id <id>] [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 
 function failUsage(message: string): void {
   process.stdout.write(`${JSON.stringify({
     status: 'failed',
     changed: false,
-    intent: 'finalize-summary',
+    intent: 'review-operation',
     error: { code: 'REVIEW_PAYLOAD_INVALID', message }
   })}\n`);
   process.stderr.write(USAGE);
@@ -28,6 +28,7 @@ async function taskReview(args: string[] = []): Promise<void> {
   try { request = parseReviewCommand(args); }
   catch (error) { failUsage(error instanceof Error ? error.message : String(error)); return; }
   const { stage, artifact, recoveryId, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+  const operation = args[1]!;
   const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
   if (dryRunConflict) { failUsage(dryRunConflict.message); return; }
   const resolved = resolveTaskRef(args[0]!);
@@ -35,8 +36,11 @@ async function taskReview(args: string[] = []): Promise<void> {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', async () => {
-      let current = finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-review.${operation}`, async () => {
+      let current = operation === 'preflight'
+        ? preflightReviewSummary({ taskRef: args[0]!, stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true })
+        : finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true });
+      if (operation === 'preflight') return current;
       if (current.status !== 'failed' || !overrideTicket) return current;
       if (!overrideTarget || !overrideScope) { failUsage('override ticket requires target and scope'); return current; }
       const consumed = await consumeHumanOverride({