@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/lib/internal/agent-client.ts

@@ -7,11 +7,11 @@ import {
 } from '../agent-clients/config.ts';
 import { normalizeCustomToolInvocations } from '../agent-clients/custom-tool-invocations.ts';
 import { renderNextStepCommands } from '../agent-clients/next-steps.ts';
-import { getAgentClientAdapter, getAgentClientModelSelection } from '../agent-clients/registry.ts';
+import { getAgentClientModelSelection } from '../agent-clients/registry.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection|launch-carrier> [options]\n';
+const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection> [options]\n';
 
 type ParsedArgs = Readonly<{
   skillName: string;
@@ -20,14 +20,6 @@ type ParsedArgs = Readonly<{
   format: 'text' | 'json';
 }>;
 
-type LaunchCarrierArgs = Readonly<{
-  client: string;
-  adapterContext: string;
-  stage: string;
-  round: number;
-  role: string;
-}>;
-
 function failure(code: string, message: string): void {
   process.stdout.write(`${JSON.stringify({
     status: 'failed',
@@ -92,63 +84,6 @@ function parseArgs(args: string[]): ParsedArgs | null {
   };
 }
 
-function parseLaunchCarrierArgs(args: string[]): LaunchCarrierArgs | null {
-  const allowed = new Set(['--client', '--adapter-context', '--stage', '--round', '--role', '--format']);
-  const values: Record<string, string> = {};
-  const seen = new Set<string>();
-  for (let index = 1; index < args.length; index += 1) {
-    const flag = args[index]!;
-    if (!allowed.has(flag) || seen.has(flag)) {
-      failure('AGENT_CLIENT_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
-      return null;
-    }
-    const value = args[++index];
-    if (!value || value.startsWith('--')) {
-      failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
-      return null;
-    }
-    seen.add(flag);
-    values[flag] = value;
-  }
-  const round = Number(values['--round']);
-  if (!isAgentClientId(values['--client']) || !values['--adapter-context'] || !values['--stage'] || !values['--role']
-    || !Number.isSafeInteger(round) || round < 1 || (values['--format'] ?? 'json') !== 'json') {
-    failure('AGENT_CLIENT_PAYLOAD_INVALID', 'launch-carrier requires client, adapter context, stage, positive round, role, and json format');
-    return null;
-  }
-  return {
-    client: values['--client']!,
-    adapterContext: values['--adapter-context']!,
-    stage: values['--stage']!,
-    round,
-    role: values['--role']!
-  };
-}
-
-function launchCarrier(args: string[]): void {
-  const parsed = parseLaunchCarrierArgs(args);
-  if (!parsed) return;
-  const createCarrier = getAgentClientAdapter(parsed.client).orchestrationAdapter?.createLaunchCarrier;
-  if (!createCarrier) {
-    process.stdout.write(`${JSON.stringify({
-      status: 'failed', changed: false, client: parsed.client, carrier: null,
-      error: { code: 'AGENT_CLIENT_LAUNCH_CARRIER_UNSUPPORTED', message: `Agent Client '${parsed.client}' does not support lifecycle launch carriers` }
-    })}\n`);
-    process.exitCode = 1;
-    return;
-  }
-  try {
-    const carrier = createCarrier(parsed.adapterContext, { stage: parsed.stage, round: parsed.round, role: parsed.role });
-    process.stdout.write(`${JSON.stringify({ status: 'ready', changed: false, client: parsed.client, carrier, error: null })}\n`);
-  } catch (error) {
-    process.stdout.write(`${JSON.stringify({
-      status: 'failed', changed: false, client: parsed.client, carrier: null,
-      error: { code: error instanceof Error && error.name ? error.name : 'AGENT_CLIENT_LAUNCH_CARRIER_INVALID', message: error instanceof Error ? error.message : String(error) }
-    })}\n`);
-    process.exitCode = 1;
-  }
-}
-
 function modelSelection(args: string[]): void {
   const values: Record<string, string> = {};
   const seen = new Set<string>();
@@ -245,9 +180,6 @@ function writeNextStepOutput(
 
 function agentClient(args: string[] = []): void {
   if (!ensureInternalHandlerRoute('agent-client', args)) return;
-  if (internalHandlerRoute('agent-client', 'launch-carrier', args[0] ?? '')) {
-    return launchCarrier(args);
-  }
   if (internalHandlerRoute('agent-client', 'model-selection', args[0] ?? '')) {
     return modelSelection(args);
   }

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

@@ -36,8 +36,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-create': ['input'],
   'task-qualification': ['proposal', 'confirm', 'supersede', 'revoke'],
   'sandbox-control': ['serve', 'execute', 'recover', 'client'],
-  'agent-client': ['next-steps', 'model-selection', 'launch-carrier'],
-  'codex-lifecycle': ['preflight', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
+  'agent-client': ['next-steps', 'model-selection'],
   'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
   'task-delivery': ['deliver'],
   'release-workflow': ['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'],
@@ -57,7 +56,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-warning': ['list', 'add', 'set-status'],
   'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
   'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],
-  'task-orchestration': ['status', 'progress'],
   'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
   'task-lifecycle': ['intent'],
@@ -95,7 +93,6 @@ export function internalRouteSelector(command: string, args: readonly string[]):
   if (command === 'task-snapshot') return 'snapshot';
   if (command === 'task-validate') return optionValue(args, '--scope') ?? 'snapshot';
   if (command === 'task-short-id') return first(args) === 'list' && args.includes('--verify') ? 'list-verify' : first(args);
-  if (command === 'task-orchestration') return args[1] === 'status' ? 'status' : args[1] ? 'progress' : '';
   if (command === 'task-review') return args[1] ?? '';
   if (command === 'task-artifact') return args[1] ?? '';
   if (command === 'platform-pr-review' && first(args) === 'publish') {

package/lib/internal/manual-validation.ts

@@ -1,11 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { locateActivityLog, pairEntries } from '../task/activity-log.ts';
+import { activityWarnings } from '../task/activity-log.ts';
+import { lifecycleExecutions } from '../task/lifecycle-execution.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { prepareAndRenderPrSummaryContent } from '../platform/pr-summary.ts';
 import { applyTaskEvent } from '../task/events.ts';
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
-import { MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, readManualValidationReceipt, writeManualValidationReceiptAtomic } from '../task/manual-validation-receipt.ts';
+import { createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, readManualValidationReceipt, writeManualValidationReceiptAtomic } from '../task/manual-validation-receipt.ts';
 import { archiveManualValidationGeneration, createManualValidationTransaction, readManualValidationTransaction, retryManualValidationTransaction, summaryPreimageDigest, transitionManualValidationTransaction, validateManualValidationGenerationArchive, writeManualValidationTransactionAtomic } from '../task/manual-validation-transaction.ts';
 import type { ManualValidationTransaction } from '../task/manual-validation-transaction.ts';
 import type { ManualValidationReceipt } from '../task/manual-validation-receipt.ts';
@@ -42,38 +44,28 @@ function printFailure(format: OutputFormat, error: { code: string; message: stri
   process.exitCode = 1;
 }
 
-const MANUAL_VALIDATION_STATUS_HEADING = /^###\s+(?:⚠️\s+(?:需人工校验|Manual Validation Required)|✅\s+(?:人工验证已通过|无需人工校验|Manual Validation Passed|No Manual Validation Required)|⏳\s+(?:人工验证待收尾|Manual Validation Pending))\s*$/mu;
-
 function manualSummaryBody(body: string, phase: 'pending' | 'final'): string {
-  const chinese = /###\s+(?:⚠️\s+需人工校验|✅\s+(?:人工验证已通过|无需人工校验)|⏳\s+人工验证待收尾)\s*$/mu.test(body);
-  const heading = phase === 'pending'
-    ? chinese ? '### ⏳ 人工验证待收尾' : '### ⏳ Manual Validation Pending'
-    : chinese ? '### ✅ 人工验证已通过' : '### ✅ Manual Validation Passed';
-  const marker = phase === 'final'
-    ? `\n\n${MANUAL_VALIDATION_RECEIPT_PLACEHOLDER}`
-    : '';
-  if (MANUAL_VALIDATION_STATUS_HEADING.test(body)) {
-    return `${body.replace(MANUAL_VALIDATION_STATUS_HEADING, `${heading}${marker}`).replace(/\s+$/u, '')}\n`;
-  }
-  const fallback = phase === 'pending'
-    ? chinese ? '人工验证正在等待最终完成。' : 'Manual validation is awaiting final promotion.'
-    : chinese ? '人工验证已通过。' : 'Manual validation passed.';
-  return `${body.replace(/\s+$/u, '')}\n\n${heading}${marker}\n\n${fallback}\n`;
+  const content = JSON.parse(body) as Record<string, unknown>;
+  const manual = content.manualValidation as Record<string, unknown>;
+  manual.state = phase === 'pending' ? 'pending' : 'passed';
+  return JSON.stringify(content);
+}
+
+function renderedManualSummaryBody(body: string, phase: 'pending' | 'final', taskContent: string): string {
+  return prepareAndRenderPrSummaryContent(JSON.parse(manualSummaryBody(body, phase)), taskContent).rendered;
 }
 
 function openManualValidationStarted(taskMdPath: string): { present: boolean; transactionId: string | null } {
   let content: string;
   try { content = fs.readFileSync(taskMdPath, 'utf8'); }
   catch { return { present: false, transactionId: null }; }
-  const section = locateActivityLog(content);
-  if (!section) return { present: false, transactionId: null };
-  const row = pairEntries(section.entries)
-    .filter((item) => item.step === 'Complete Manual Validation' && item.started && !item.done)
+  const row = lifecycleExecutions(content)
+    .filter((item) => item.family === 'manual-validation')
     .at(-1);
   if (!row) return { present: false, transactionId: null };
   return {
     present: true,
-    transactionId: /(?:^|;\s*)transaction=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:;|$)/u.exec(row.note)?.[1] ?? null
+    transactionId: row.transactionId ?? null
   };
 }
 
@@ -112,6 +104,7 @@ async function executeManualValidationTransactionAtResolvedTask(
   const preimage = { commentId: currentState.comment?.id ?? null, body: preimageBody, digest: summaryPreimageDigest(preimageBody) };
   const summaryPath = path.resolve(cwd, values.summaryFile!);
   const finalBodyWithoutReceipt = fs.readFileSync(summaryPath, 'utf8');
+  const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
   const evidenceDigest = sha256File(summaryPath);
   const archiveGeneration = options.archiveGeneration ?? archiveManualValidationGeneration;
   let transactionResult = readManualValidationTransaction(resolved.taskDir, { taskId: resolved.taskId, prNumber: pullRequest.number, prHeadSha: pullRequest.head.sha, evidenceDigest, artifact: values.artifact! });
@@ -126,7 +119,7 @@ async function executeManualValidationTransactionAtResolvedTask(
     transactionResult = { ok: false, error: { code: 'MANUAL_VALIDATION_TRANSACTION_MISSING', message: 'previous failed transaction was archived for a new pull-request head' } };
   }
   if (!transactionResult.ok && transactionResult.error.code !== 'MANUAL_VALIDATION_TRANSACTION_MISSING') return result('failed', transactionResult.error);
-  if (transactionResult.ok && transactionResult.value.phase === 'committed') return result('applied', null, { transaction: transactionResult.value, receipt: transactionResult.value.committedReceipt, idempotent: true });
+  if (transactionResult.ok && transactionResult.value.phase === 'committed') return result('applied', null, { transaction: transactionResult.value, receipt: transactionResult.value.committedReceipt, idempotent: true, warnings: activityWarnings(taskContent) });
   const openStarted = transactionResult.ok ? { present: false, transactionId: null } : openManualValidationStarted(resolved.taskMdPath);
   if (openStarted.present && !openStarted.transactionId) {
     return result('failed', { code: 'MANUAL_VALIDATION_TRANSACTION_RECOVERY_REQUIRED', message: 'open manual-validation started event has no recoverable transactionId' });
@@ -146,7 +139,7 @@ async function executeManualValidationTransactionAtResolvedTask(
     evidenceDigest,
     summaryPreimage: preimage,
     pendingSummaryDigest: summaryPreimageDigest(pendingBody),
-    finalSummaryDigest: manualValidationFinalSummaryDigest(manualSummaryBody(finalBodyWithoutReceipt, 'final')),
+    finalSummaryDigest: manualValidationFinalSummaryDigest(renderedManualSummaryBody(finalBodyWithoutReceipt, 'final', taskContent)),
     artifact: values.artifact!,
     attempt: 1,
     createdAt: new Date().toISOString(),
@@ -154,11 +147,16 @@ async function executeManualValidationTransactionAtResolvedTask(
   });
   let transaction: ManualValidationTransaction;
   const idempotent = transactionResult.ok;
+  const warnings: { code: string; message: string }[] = [];
+  const currentWarnings = () => warnings.length
+    ? warnings.filter((warning, index) => warnings.findIndex((item) => item.code === warning.code && item.message === warning.message) === index)
+    : activityWarnings(taskContent);
   let startedEventApplied = false;
   if (!transactionResult.ok) {
     transaction = createTransaction();
     const started = applyTaskEvent({ taskRef, event: 'manual-validation.started', agent, initiator: 'model', requestId: transactionId, reasonCode: 'user-request', transactionId }, { repoRoot: cwd });
     if (started.status === 'failed') return result('failed', started.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation started event failed' });
+    warnings.push(...(started.warnings ?? []));
     startedEventApplied = true;
     if (previousTransaction) {
       try { archiveGeneration(resolved.taskDir, previousTransaction, previousTransaction.phase === 'committed'); }
@@ -177,8 +175,9 @@ async function executeManualValidationTransactionAtResolvedTask(
   if (transaction.phase === 'prepared' && !startedEventApplied) {
     const started = applyTaskEvent({ taskRef, event: 'manual-validation.started', agent, initiator: 'model', requestId: transaction.transactionId, reasonCode: 'user-request', transactionId: transaction.transactionId }, { repoRoot: cwd });
     if (started.status === 'failed') return result('failed', started.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation started event failed' });
+    warnings.push(...(started.warnings ?? []));
   }
-  if (prepareOnly) return result('applied', null, { transaction, prepared: true, idempotent });
+  if (prepareOnly) return result('applied', null, { transaction, prepared: true, idempotent, warnings: currentWarnings() });
   const transactionFailure = (failure: { code: string; message: string }): never => {
     throw new Error(`${failure.code}: ${failure.message}`);
   };
@@ -233,6 +232,7 @@ async function executeManualValidationTransactionAtResolvedTask(
     if (transaction.phase === 'receipt-committed' && !transaction.eventAppended) {
       const completed = applyTaskEvent({ taskRef, event: 'manual-validation.completed', agent, initiator: 'model', requestId: transaction.transactionId, reasonCode: 'user-request', artifact: values.artifact, summaryResult: 'human-confirmed validation and committed receipt', transactionId: transaction.transactionId, receiptDigest: receipt.receiptDigest, prHeadSha: receipt.prHeadSha }, { repoRoot: cwd });
       if (completed.status === 'failed') transactionFailure(completed.error ?? { code: 'MANUAL_VALIDATION_TRANSACTION_FAILED', message: 'manual-validation completion event failed' });
+      warnings.push(...(completed.warnings ?? []));
       transitionAndPersist('receipt-committed', { eventAppended: true });
     }
     if (transaction.phase === 'receipt-committed') {
@@ -246,7 +246,7 @@ async function executeManualValidationTransactionAtResolvedTask(
     const postWrite = await summaryCommentState(taskRef, { cwd, client: options.client });
     if (!/^###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)\s*$/mu.test(postWrite.comment?.body ?? '') || postWrite.pullRequest?.head.sha !== receipt.prHeadSha || !manualValidationFinalSummaryProjectionMatches(postWrite.comment?.body ?? '', receipt)) transactionFailure({ code: 'MANUAL_VALIDATION_TRANSACTION_RECOVERY_REQUIRED', message: 'final summary post-write verification failed' });
     transitionAndPersist('committed', { postWriteVerified: true });
-    return result('applied', null, { transaction, receipt, idempotent: false });
+    return result('applied', null, { transaction, receipt, idempotent: false, warnings: currentWarnings() });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (transaction.phase === 'final-promotion-in-progress') {
@@ -298,6 +298,7 @@ async function manualValidation(args: string[] = []): Promise<void> {
   const format = values.format === 'text' ? 'text' : 'json';
   const output = await executeManualValidationTransaction(taskRef, values, path.resolve(values.cwd ?? process.cwd()));
   process.stdout.write(format === 'json' ? `${JSON.stringify(output)}\n` : `${output.status === 'applied' ? 'Manual validation transaction committed.' : `${output.error?.code}: ${output.error?.message}`}\n`);
+  if (format === 'text' && Array.isArray(output.warnings)) for (const warning of output.warnings) process.stderr.write(`${warning.code}: ${warning.message}\n`);
   if (output.status === 'failed') process.exitCode = 1;
 }
 

package/lib/internal/platform-comment.ts

@@ -17,6 +17,9 @@ import { recoverTaskFromComments } from '../platform/task-recovery.ts';
 import { backfillCompletionComments } from '../platform/completion-backfill.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { enumerateArtifacts } from '../task/artifacts.ts';
+import { parseTaskFrontmatter } from '../task/frontmatter.ts';
+import { prepareAndRenderCancelSummaryContent, prepareAndRenderDeliverySummaryContent } from '../platform/issue-summary-content.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>]
@@ -158,13 +161,26 @@ async function platformComment(args: string[] = []): Promise<void> {
     let body: string;
     try { body = readBodyFile(parsed.values.bodyFile, cwd); }
     catch (error) { fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`); return; }
-    const canonical = canonicalizeSummaryBody(body);
-    if (!canonical.ok) { fail(`unable to stage summary: ${canonical.error.code}: ${canonical.error.message}`); return; }
-    body = canonical.value;
     const resolved = resolveTaskRef(taskRef!, { repoRoot: cwd });
     if (!resolved.ok || resolved.state !== 'active') { fail('stage-summary requires an active task'); return; }
     const target = path.join(resolved.taskDir, '.delivery-summary.json');
-    const value = { taskId: resolved.taskId, body, sha256: createHash('sha256').update(body).digest('hex') };
+    let content;
+    try {
+      const supplied = JSON.parse(body) as Record<string, unknown>;
+      const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+      const title = /^#\s+(.+)$/mu.exec(taskContent)?.[1]?.trim();
+      const prepared = prepareAndRenderDeliverySummaryContent(supplied, {
+        taskId: resolved.taskId,
+        title: title || resolved.taskId,
+        artifacts: enumerateArtifacts(resolved.taskDir).filter((artifact) => artifact.name !== 'task.md').map((artifact) => artifact.name),
+        verificationFallback: { state: 'not-run', detail: 'Final verification has not run at summary staging.' }
+      });
+      content = prepared.content;
+      const canonical = canonicalizeSummaryBody(prepared.rendered);
+      if (!canonical.ok) throw new Error(`${canonical.error.code}: ${canonical.error.message}`);
+      body = canonical.value;
+    } catch (error) { fail(`unable to stage summary: ${error instanceof Error ? error.message : String(error)}`); return; }
+    const value = { taskId: resolved.taskId, content, contentSha256: createHash('sha256').update(JSON.stringify(content)).digest('hex') };
     const previous = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : null;
     const next = `${JSON.stringify(value)}\n`;
     if (previous === next) {
@@ -199,6 +215,32 @@ async function platformComment(args: string[] = []): Promise<void> {
     fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
+  if (kind === 'summary' || kind === 'cancel') {
+    try {
+      const input = JSON.parse(body!) as Record<string, unknown>;
+      const resolved = resolveTaskRef(taskRef!, { repoRoot: cwd });
+      if (!resolved.ok) throw new Error(resolved.message);
+      const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+      const taskFrontmatter = parseTaskFrontmatter(taskContent);
+      const title = /^#\s+(.+)$/mu.exec(taskContent)?.[1]?.trim();
+      const artifacts = enumerateArtifacts(resolved.taskDir).filter((artifact) => artifact.name !== 'task.md').map((artifact) => artifact.name);
+      const rendered = kind === 'summary'
+        ? prepareAndRenderDeliverySummaryContent(input, {
+          taskId: resolved.taskId,
+          title: title || resolved.taskId,
+          artifacts,
+          ...(resolved.state === 'active' ? { verificationFallback: { state: 'not-run', detail: 'Final verification has not run at summary staging.' } } : {})
+        }).rendered
+        : prepareAndRenderCancelSummaryContent(input, {
+          taskId: resolved.taskId,
+          title: title || resolved.taskId,
+          reason: typeof taskFrontmatter.cancel_reason === 'string' ? taskFrontmatter.cancel_reason : '',
+          cancelledAt: typeof taskFrontmatter.cancelled_at === 'string' ? taskFrontmatter.cancelled_at : '',
+          lastCompletedArtifact: artifacts.at(-1) ?? null
+        }).rendered;
+      body = rendered;
+    } catch (error) { fail(`invalid ${kind} summary structure: ${error instanceof Error ? error.message : String(error)}`); return; }
+  }
   finish(await syncPlatformComment(taskRef!, {
     kind: kind as CommentKind,
     agent: normalizedAgent,

package/lib/internal/task-create.ts

@@ -11,7 +11,6 @@ import { validateTaskCreateCandidate, type TaskCreateCandidateV1 } from '../task
 import {
   createTask,
   parseTaskCreateResult,
-  projectTaskCreateResult,
   taskCreateExitCode,
   taskCreateFailure,
   type TaskCreateControl,

package/lib/internal/task-event.ts

@@ -4,7 +4,7 @@ import type { TaskEventRequest, Verdict } from '../task/events.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
+const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
 Events: ${eventCatalog.join(', ')}
@@ -35,10 +35,6 @@ export function parseTaskEventRequest(args: readonly string[]): TaskEventRequest
   const seen = new Set<string>();
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (flag === '--orchestrated') {
-      if (seen.has(flag)) throw new Error(`duplicate option '${flag}'`);
-      seen.add(flag); request.orchestrated = true; continue;
-    }
     if (flag === '--dry-run') {
       if (seen.has(flag)) throw new Error(`duplicate option '${flag}'`);
       seen.add(flag); request.dryRun = true; continue;

package/lib/internal/task-finalization.ts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import {
   createDirectHostExecutionContext,
   dispatchTaskControlOperation,

package/lib/internal/task-lifecycle.ts

@@ -6,12 +6,10 @@ import {
 } from '../task/control-authority.ts';
 import { lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
-import type { TaskLifecycleResult } from '../task/lifecycle.ts';
-import type { AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult } from '../agent-clients/adapter.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 import { loadSandboxControlLocation } from '../sandbox/config.ts';
 
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\nrecover-started: --auto\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.filter((intent) => intent !== 'complete').join(', ')}\n`;
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
@@ -64,9 +62,9 @@ async function taskLifecycle(args: string[] = []): Promise<void> {
   const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }),
     operation
-  ) as TaskLifecycleResult | LifecycleRecoveryResult;
+  );
   process.stdout.write(`${JSON.stringify(result)}\n`);
-  if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict') process.exitCode = 1;
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskLifecycle };

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

@@ -1,9 +1,7 @@
 import fs from 'node:fs';
-import path from 'node:path';
 
 import {
   accessSandboxTaskView,
-  parseSandboxTaskView,
   taskViewFromStatus,
   type SandboxTaskView,
   type TaskViewAccessEffect
@@ -14,7 +12,7 @@ import {
   PUBLIC_CLI_SELECTOR_ALIASES,
   internalRouteSelector
 } from './cli-route-inventory.ts';
-import { hasSandboxControlMarker, resolveSandboxControlTransport, sandboxTaskMarkerState } from '../sandbox/environment.ts';
+import { hasSandboxControlMarker, sandboxTaskMarkerState } from '../sandbox/environment.ts';
 export { resolveSandboxControlTransport } from '../sandbox/environment.ts';
 
 export type TaskOperationDispatcher = 'public' | 'internal';
@@ -54,12 +52,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'sandbox-control', 'client', 'conditional', 'progress', 'delegated'),
     descriptor('internal', 'agent-client', 'next-steps', 'non-task', 'diagnostic', 'none'),
     descriptor('internal', 'agent-client', 'model-selection', 'non-task', 'diagnostic', 'none'),
-    descriptor('internal', 'agent-client', 'launch-carrier', 'non-task', 'diagnostic', 'none'),
-    descriptor('internal', 'codex-lifecycle', 'preflight', 'non-task', 'diagnostic', 'none'),
-    descriptor('internal', 'codex-lifecycle', 'hook-event', 'conditional', 'progress'),
-    descriptor('internal', 'codex-lifecycle', 'resolve-start', 'conditional', 'progress'),
-    descriptor('internal', 'codex-lifecycle', 'resolve-stop', 'conditional', 'progress'),
-    descriptor('internal', 'codex-lifecycle', 'consume', 'conditional', 'progress'),
     descriptor('internal', 'git-workflow', 'inspect', 'conditional', 'diagnostic'),
     descriptor('internal', 'git-workflow', 'preview-tree', 'conditional', 'diagnostic'),
     descriptor('internal', 'git-workflow', 'snapshot', 'conditional', 'diagnostic'),
@@ -132,8 +124,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     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'),
@@ -212,11 +202,11 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
 ]);
 
 export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
-  'task-create', 'task-qualification', 'sandbox-control', 'agent-client', 'codex-lifecycle',
+  'task-create', 'task-qualification', 'sandbox-control', 'agent-client',
   '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-workspace', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
-  'task-orchestration', 'task-review', 'task-event', 'task-lifecycle',
+  'task-review', 'task-event', 'task-lifecycle',
   'task-finalization', 'task-platform-recovery', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);
 export const PUBLIC_DISPATCHER_ROUTES = Object.freeze([
@@ -271,7 +261,6 @@ 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));
 }
 
@@ -298,7 +287,6 @@ function explicitTaskRefForOperation(
     }
     return command === 'merge' ? null : first(args) || null;
   }
-  if (command === 'codex-lifecycle') return optionValue(args, '--task-id') ?? null;
   if (command === 'platform-comment' || command === 'platform-issue') {
     return first(args) === 'list' ? null : args[1] ?? null;
   }
@@ -449,7 +437,3 @@ export function guardTaskOperation(
   }
   return { descriptor: selected, taskView };
 }
-
-export function assertTaskViewStatus(value: unknown): SandboxTaskView {
-  return parseSandboxTaskView(value);
-}

package/lib/internal/task-review.ts

@@ -3,7 +3,7 @@ import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-fi
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--dry-run]\n';
 
 function failUsage(message: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -25,13 +25,13 @@ async function taskReview(args: string[] = []): Promise<void> {
   let request;
   try { request = parseReviewCommand(args); }
   catch (error) { failUsage(error instanceof Error ? error.message : String(error)); return; }
-  const { stage, artifact, dryRun, orchestrated } = request;
+  const { stage, artifact, dryRun } = request;
   const operation = args[1]!;
   const resolved = resolveTaskRef(args[0]!);
   if (!resolved.ok) { failUsage(resolved.message); return; }
   const result = operation === 'preflight'
-    ? preflightReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun })
-    : finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, orchestrated, dryRun });
+    ? preflightReviewSummary({ taskRef: args[0]!, stage, artifact, dryRun })
+    : finalizeReviewSummary({ taskRef: args[0]!, stage, artifact, dryRun });
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }

package/lib/platform/comment-safety.ts

@@ -94,14 +94,6 @@ function escapeHtmlText(value: string): string {
   return escapeHtml(value);
 }
 
-function escapeHtmlAttribute(value: string): string {
-  return escapeHtml(value);
-}
-
-function escapeMarkdownLiteral(value: string): string {
-  return value.replace(/[\\`*_{}\[\]()#+.!|<>-]/g, '\\$&');
-}
-
 function markerSafe(value: string, markers: readonly RegExp[]): string {
   let result = value;
   for (const marker of markers) {
@@ -250,9 +242,7 @@ function splitDocumentPlaceholder(value: string, placeholder: string): Sanitizat
 
 export {
   CONTROL_MARKER_PATTERN,
-  escapeHtmlAttribute,
   escapeHtmlText,
-  escapeMarkdownLiteral,
   fenceRanges,
   renderSafeCodeFence,
   canonicalizeCommentBody,

package/lib/platform/github-provider.ts

@@ -15,7 +15,6 @@ import type {
   ChangeRequestSnapshot,
   CheckLogSnapshot,
   CheckRunSnapshot,
-  GitEvidenceSnapshot,
   IssueSnapshot,
   LabelReconciliation,
   MutationReceipt,
@@ -32,7 +31,6 @@ import type {
   ReleaseSnapshot,
   RemoteCommentSnapshot,
   ReviewSnapshot,
-  SecurityAlertKind,
   SecurityAlertSnapshot,
   VerificationRemoteFacts
 } from './provider-contract.ts';

package/lib/platform/in-label-sync.ts

@@ -182,16 +182,6 @@ function flattenPages(value: unknown): unknown[] {
   return value.flatMap((page) => Array.isArray(page) ? page : [page]);
 }
 
-function extractRepositoryLabelNames(value: unknown): string[] {
-  return flattenPages(value).flatMap((entry) => {
-    if (typeof entry === 'string') return [entry];
-    if (entry && typeof entry === 'object' && typeof (entry as { name?: unknown }).name === 'string') {
-      return [(entry as { name: string }).name];
-    }
-    return [];
-  }).filter(Boolean).sort();
-}
-
 function extractPullRequestFileNames(value: unknown): string[] | null {
   const entries = flattenPages(value);
   if (!Array.isArray(value) || entries.some((entry) => !entry || typeof entry !== 'object')) return null;
@@ -200,20 +190,14 @@ function extractPullRequestFileNames(value: unknown): string[] | null {
   return [...new Set(names as string[])].sort();
 }
 
-function resourceSnapshot(kind: InLabelResource['kind'], number: number, labels: readonly string[]): InLabelResource {
-  return { kind, number, labels: [...labels].sort() };
-}
-
 export {
   extractPullRequestFileNames,
-  extractRepositoryLabelNames,
   flattenPages,
   inLabels,
   inLabelMappingDigest,
   labelDelta,
   mergeInLabels,
   planInLabelUpdate,
-  resourceSnapshot,
   syncLabelDelta,
   validateInLabelMapping,
   validateRepositoryLabelPayload