@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/internal/manual-validation.js

@@ -1,10 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { locateActivityLog, pairEntries } from '../task/activity-log.js';
+import { activityWarnings } from '../task/activity-log.js';
+import { lifecycleExecutions } from '../task/lifecycle-execution.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { prepareAndRenderPrSummaryContent } from '../platform/pr-summary.js';
 import { applyTaskEvent } from '../task/events.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, readManualValidationReceipt, writeManualValidationReceiptAtomic } from '../task/manual-validation-receipt.js';
+import { createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, readManualValidationReceipt, writeManualValidationReceiptAtomic } from '../task/manual-validation-receipt.js';
 import { archiveManualValidationGeneration, createManualValidationTransaction, readManualValidationTransaction, retryManualValidationTransaction, summaryPreimageDigest, transitionManualValidationTransaction, validateManualValidationGenerationArchive, writeManualValidationTransactionAtomic } from '../task/manual-validation-transaction.js';
 import { sha256File } from '../task/artifact-receipts.js';
 import { summaryCommentState, syncPullRequestSummary } from '../platform/pr-summary.js';
@@ -21,22 +23,14 @@ function printFailure(format, error) {
         process.stderr.write(`${error.code}: ${error.message}\n`);
     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, phase) {
-    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);
+    const manual = content.manualValidation;
+    manual.state = phase === 'pending' ? 'pending' : 'passed';
+    return JSON.stringify(content);
+}
+function renderedManualSummaryBody(body, phase, taskContent) {
+    return prepareAndRenderPrSummaryContent(JSON.parse(manualSummaryBody(body, phase)), taskContent).rendered;
 }
 function openManualValidationStarted(taskMdPath) {
     let content;
@@ -46,17 +40,14 @@ function openManualValidationStarted(taskMdPath) {
     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
     };
 }
 async function executeManualValidationTransaction(taskRef, values, cwd, options = {}) {
@@ -90,6 +81,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
     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 });
@@ -112,7 +104,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
     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 });
+        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' });
@@ -132,7 +124,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
         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(),
@@ -140,12 +132,17 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
     });
     let transaction;
     const idempotent = transactionResult.ok;
+    const warnings = [];
+    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 {
@@ -171,9 +168,10 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
         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 });
+        return result('applied', null, { transaction, prepared: true, idempotent, warnings: currentWarnings() });
     const transactionFailure = (failure) => {
         throw new Error(`${failure.code}: ${failure.message}`);
     };
@@ -230,6 +228,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
             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') {
@@ -245,7 +244,7 @@ async function executeManualValidationTransactionAtResolvedTask(taskRef, values,
         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);
@@ -315,6 +314,9 @@ async function manualValidation(args = []) {
     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/dist/lib/internal/platform-comment.js

@@ -10,6 +10,9 @@ import { recoverTaskFromComments } from '../platform/task-recovery.js';
 import { backfillCompletionComments } from '../platform/completion-backfill.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { enumerateArtifacts } from '../task/artifacts.js';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { prepareAndRenderCancelSummaryContent, prepareAndRenderDeliverySummaryContent } from '../platform/issue-summary-content.js';
 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>]
@@ -202,19 +205,34 @@ async function platformComment(args = []) {
             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);
+            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) {
@@ -273,6 +291,37 @@ async function platformComment(args = []) {
         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);
+            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,
         agent: normalizedAgent,

package/dist/lib/internal/task-create.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { requestSandboxTaskCreate, SandboxControlClientError } from '../sandbox/control/client.js';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.js';
 import { validateTaskCreateCandidate } from '../task/create.js';
-import { createTask, parseTaskCreateResult, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../task/create-service.js';
+import { createTask, parseTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../task/create-service.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 function failed(code, message, retryable = false, control) {
     return taskCreateFailure({ code, message, retryable }, control);

package/dist/lib/internal/task-event.js

@@ -2,7 +2,7 @@ import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.j
 import { applyTaskEvent, eventCatalog } from '../task/events.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-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(', ')}
@@ -31,13 +31,6 @@ export function parseTaskEventRequest(args) {
     const seen = new Set();
     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}'`);

package/dist/lib/internal/task-finalization.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
 import { applyTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';

package/dist/lib/internal/task-lifecycle.js

@@ -3,7 +3,7 @@ import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { loadSandboxControlLocation } from '../sandbox/config.js';
-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) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -56,7 +56,7 @@ async function taskLifecycle(args = []) {
     const controlLocation = loadSandboxControlLocation(repoRoot);
     const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot, ...(controlLocation ?? {}) }), operation);
     process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict')
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskLifecycle };

package/dist/lib/internal/task-operation-registry.js

@@ -1,9 +1,8 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { accessSandboxTaskView, parseSandboxTaskView, taskViewFromStatus } from '../sandbox/control/task-view.js';
+import { accessSandboxTaskView, taskViewFromStatus } from '../sandbox/control/task-view.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { PUBLIC_CLI_COMMAND_ALIASES, PUBLIC_CLI_SELECTOR_ALIASES, internalRouteSelector } from './cli-route-inventory.js';
-import { hasSandboxControlMarker, resolveSandboxControlTransport, sandboxTaskMarkerState } from '../sandbox/environment.js';
+import { hasSandboxControlMarker, sandboxTaskMarkerState } from '../sandbox/environment.js';
 export { resolveSandboxControlTransport } from '../sandbox/environment.js';
 const descriptor = (dispatcher, command, selector, scope, effect, taskRefSource = scope === 'non-task' ? 'none' : 'argv') => ({ dispatcher, command, selector, scope, effect, taskRefSource, guardBeforeImport: true });
 function internalTaskRoutes() {
@@ -19,12 +18,6 @@ function internalTaskRoutes() {
         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'),
@@ -97,8 +90,6 @@ function internalTaskRoutes() {
         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'),
@@ -174,11 +165,11 @@ export const TASK_OPERATION_DESCRIPTORS = Object.freeze([
     ...PUBLIC_OPERATION_DESCRIPTORS
 ]);
 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([
@@ -228,8 +219,6 @@ export function resolveDelegatedTaskOperation(args) {
     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));
 }
 function explicitTaskRefForOperation(dispatcher, command, args, selected) {
@@ -253,8 +242,6 @@ function explicitTaskRefForOperation(dispatcher, command, args, selected) {
         }
         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;
     }
@@ -391,7 +378,4 @@ export function guardTaskOperation(dispatcher, command, args = [], options = {})
     }
     return { descriptor: selected, taskView };
 }
-export function assertTaskViewStatus(value) {
-    return parseSandboxTaskView(value);
-}
 //# sourceMappingURL=task-operation-registry.js.map

package/dist/lib/internal/task-review.js

@@ -2,7 +2,7 @@ import { parseReviewCommand } from '../task/review-command.js';
 import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
-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) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -28,7 +28,7 @@ async function taskReview(args = []) {
         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) {
@@ -36,8 +36,8 @@ async function taskReview(args = []) {
         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/dist/lib/platform/comment-safety.js

@@ -75,12 +75,6 @@ function escapeHtml(value) {
 function escapeHtmlText(value) {
     return escapeHtml(value);
 }
-function escapeHtmlAttribute(value) {
-    return escapeHtml(value);
-}
-function escapeMarkdownLiteral(value) {
-    return value.replace(/[\\`*_{}\[\]()#+.!|<>-]/g, '\\$&');
-}
 function markerSafe(value, markers) {
     let result = value;
     for (const marker of markers) {
@@ -231,5 +225,5 @@ function splitDocumentPlaceholder(value, placeholder) {
     }
     return ok({ prefix: source.slice(0, position), suffix: source.slice(position + placeholder.length) });
 }
-export { CONTROL_MARKER_PATTERN, escapeHtmlAttribute, escapeHtmlText, escapeMarkdownLiteral, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, canonicalizeSummaryBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
+export { CONTROL_MARKER_PATTERN, escapeHtmlText, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, canonicalizeSummaryBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
 //# sourceMappingURL=comment-safety.js.map

package/dist/lib/platform/in-label-sync.js

@@ -129,16 +129,6 @@ function flattenPages(value) {
         return [];
     return value.flatMap((page) => Array.isArray(page) ? page : [page]);
 }
-function extractRepositoryLabelNames(value) {
-    return flattenPages(value).flatMap((entry) => {
-        if (typeof entry === 'string')
-            return [entry];
-        if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
-            return [entry.name];
-        }
-        return [];
-    }).filter(Boolean).sort();
-}
 function extractPullRequestFileNames(value) {
     const entries = flattenPages(value);
     if (!Array.isArray(value) || entries.some((entry) => !entry || typeof entry !== 'object'))
@@ -148,8 +138,5 @@ function extractPullRequestFileNames(value) {
         return null;
     return [...new Set(names)].sort();
 }
-function resourceSnapshot(kind, number, labels) {
-    return { kind, number, labels: [...labels].sort() };
-}
-export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, inLabelMappingDigest, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
+export { extractPullRequestFileNames, flattenPages, inLabels, inLabelMappingDigest, labelDelta, mergeInLabels, planInLabelUpdate, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
 //# sourceMappingURL=in-label-sync.js.map