@fitlab-ai/agent-infra 0.11.1 → 0.11.3

package/dist/bin/internal-cli.js

@@ -49,7 +49,9 @@ function taskControlTransportFailure(message, code = 'TASK_CONTROL_TRANSPORT_INV
 }
 let controlRouted = false;
 if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkflowCommand || manualValidationWorkflowCommand)) {
-    const transport = resolveSandboxControlTransport(process.env);
+    const transport = resolveSandboxControlTransport(process.env, {
+        localWorkflow: command === 'task-orchestration' || taskWorkflowCommand || manualValidationWorkflowCommand
+    });
     switch (transport.kind) {
         case 'fail-closed': {
             const reason = transport.reasonCode ?? 'TASK_CONTROL_TRANSPORT_INVALID';
@@ -60,9 +62,12 @@ if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkfl
             // The host CLI is the direct-host authority. Domain handlers retain their
             // task locks, atomic writes, and operation-specific recovery facts.
             break;
+        case 'sandbox-local': {
+            break;
+        }
         case 'broker-client': {
             const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
-            await sandboxControl(['client', ...(taskControlCommand ? [command] : ['task-workflow', command]), ...process.argv.slice(3)]);
+            await sandboxControl(['client', command, ...process.argv.slice(3)]);
             break;
         }
     }

package/dist/lib/agent-clients/adapter.js

@@ -408,6 +408,9 @@ function defineAgentClientAdapter(candidate) {
         capabilities: Object.freeze(capabilities),
         modelSelection: frozenModelSelection,
         delegationEvidence: Object.freeze({ ...evidence }),
+        ...(candidate.orchestrationAdapter === undefined
+            ? {}
+            : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
         project: Object.freeze({
             ownedPathPrefixes: Object.freeze(paths),
             ...projectAssets,

package/dist/lib/agent-clients/adapters/codex-lifecycle/recovery.js

@@ -0,0 +1,234 @@
+import fs from 'node:fs';
+import { createCodexLifecycleStore } from './store.js';
+import { managedDelegationRole } from '../../../task/delegation-receipts.js';
+import { normalizeAgentToken } from '../../tokens.js';
+import { locateActivityLog, pairEntries, appendActivityEntry } from '../../../task/activity-log.js';
+import { captureTaskWriteMetadata, writeTask } from '../../../task/write.js';
+import { parseTypedTaskFrontmatter } from '../../../task/frontmatter.js';
+import { resolveTaskRef } from '../../../task/resolve-ref.js';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
+import { recoverActivatedOrchestrationDelegationUnderLock, readRun } from '../../../task/orchestration.js';
+const ACTIONS = {
+    analysis: 'Analyze Task',
+    'review-analysis': 'Review Analysis',
+    plan: 'Plan Task',
+    'review-plan': 'Review Plan',
+    code: 'Code Task',
+    'review-code': 'Review Code'
+};
+function result(request, status, extra = {}) {
+    return {
+        status,
+        changed: status === 'applied',
+        targetState: 'active',
+        requestRef: request.taskRef,
+        intent: 'recover-started',
+        taskId: null,
+        receiptId: null,
+        childId: null,
+        error: null,
+        ...extra
+    };
+}
+function failure(request, status, code, message, extra = {}) {
+    return result(request, status, { error: { code, message }, ...extra });
+}
+function actionPattern(receipt) {
+    const action = ACTIONS[receipt.stage];
+    if (!action)
+        return null;
+    const escaped = action.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return new RegExp(`^${escaped} \\(Round ${receipt.round}(?:, (?:fix for review-code(?:-r[2-9]|-r[1-9]\\d+)?.md|decision II-[1-9]\\d*))?\\)$`, 'u');
+}
+function openRows(section) {
+    return pairEntries([...section.entries]).filter((row) => row.started !== '' && row.done === '');
+}
+function rowForReceipt(rows, receipt) {
+    const pattern = actionPattern(receipt);
+    return pattern ? rows.filter((row) => pattern.test(row.step)) : [];
+}
+function readLifecycleStore(options, repoRoot) {
+    return options.lifecycleStore ?? createCodexLifecycleStore({
+        root: resolveAgentRuntimeStoreRoot({ repoRoot, store: 'lifecycle' }),
+        cliVersion: 'recovery',
+        now: options.now
+    });
+}
+function readStoredEvidence(store, childId) {
+    try {
+        return store.read(childId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('was not found uniquely'))
+            return { missing: true };
+        return { error: error instanceof Error ? error : new Error(message) };
+    }
+}
+function validateStopRecord(record, receipt) {
+    const start = record.state.startEvidence;
+    const stop = record.state.stopEvidence;
+    const provenance = receipt.lifecycleProvenance;
+    const host = receipt.hostEvidence;
+    if (receipt.client !== 'codex'
+        || !provenance
+        || host?.kind !== 'codex-lifecycle-v2'
+        || !start
+        || !stop
+        || record.state.status !== 'stop-ready'
+        || stop.terminalStatus !== 'completed'
+        || stop.hookStopObserved !== true
+        || start.childThreadId !== receipt.childId
+        || start.parentThreadId !== receipt.parentId
+        || managedDelegationRole(start.nativeAgent) !== receipt.role
+        || start.hookDefinitionHash !== provenance.hookDefinitionHash
+        || host.hookDefinitionHash !== provenance.hookDefinitionHash
+        || host.capabilitySessionId !== provenance.capabilitySessionId
+        || host.capabilityTurnId !== provenance.capabilityTurnId
+        || host.capabilityToolUseId !== provenance.capabilityToolUseId
+        || host.spawnToolUseId !== start.spawnToolUseId
+        || !host.spawnObservedAt
+        || host.spawnObservedAt !== record.spawnObservedAt
+        || host.controllerInstanceDigest !== provenance.controllerInstanceDigest
+        || host.controlGeneration !== provenance.controlGeneration
+        || typeof host.controllerInstanceDigest !== 'string'
+        || typeof host.controlGeneration !== 'string'
+        || host.startRevision < 1
+        || record.revision <= host.startRevision
+        || record.state.child?.childThreadId !== receipt.childId
+        || record.state.stop?.childThreadId !== receipt.childId) {
+        return { ok: false, code: 'RECOVERY_STOP_EVIDENCE_INVALID', message: 'Codex stop evidence does not match the activated receipt' };
+    }
+    if (record.consumer !== null && record.consumer !== receipt.id) {
+        return { ok: false, code: 'RECOVERY_CONSUMER_CONFLICT', message: `Codex lifecycle evidence was consumed by '${record.consumer}'` };
+    }
+    return { ok: true };
+}
+function abortedCandidates(run, rows) {
+    const candidates = run.receipts.flatMap((receipt) => {
+        if (receipt.status !== 'aborted' || receipt.activatedAt === null || receipt.client !== 'codex')
+            return [];
+        const matches = rowForReceipt(rows, receipt);
+        return matches.length === 1 ? [{ receipt, row: matches[0] }] : [];
+    });
+    return candidates;
+}
+function appendRecoveryLog(request, taskId, section, candidate, repoRoot, writer) {
+    const metadata = captureTaskWriteMetadata();
+    const body = appendActivityEntry(section, {
+        time: metadata.timestamp,
+        step: `${candidate.row.step} [aborted]`,
+        agent: request.agent,
+        note: `terminated Codex delegation; receipt=${candidate.receipt.id}; child=${candidate.receipt.childId}`
+    });
+    const written = writer({
+        taskRef: taskId,
+        expectedState: 'active',
+        mutations: [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }]
+    }, { repoRoot, metadataProvider: () => metadata });
+    if (written.status === 'failed') {
+        return failure(request, 'owner-unknown', 'RECOVERY_LOG_WRITE_FAILED', written.error.message, {
+            taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
+        });
+    }
+    return result(request, 'applied', {
+        taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
+    });
+}
+function recoverStartedLifecycleUnderLock(request, options = {}) {
+    if (!request || request.intent !== 'recover-started' || request.auto !== true || normalizeAgentToken(request.agent) !== 'codex') {
+        return failure(request, 'conflict', 'RECOVERY_PAYLOAD_INVALID', 'automatic recovery requires a task and the Codex agent');
+    }
+    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return failure(request, 'conflict', resolved.code, resolved.message);
+    const taskId = resolved.taskId;
+    let content;
+    try {
+        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        parseTypedTaskFrontmatter(content);
+    }
+    catch (error) {
+        return failure(request, 'conflict', 'RECOVERY_TASK_INVALID', error instanceof Error ? error.message : String(error), { taskId });
+    }
+    const section = locateActivityLog(content);
+    if (!section)
+        return failure(request, 'conflict', 'RECOVERY_LOG_INVALID', 'task has no unique Activity Log section', { taskId });
+    let run;
+    try {
+        run = readRun(resolved.taskDir, options.orchestration);
+    }
+    catch (error) {
+        return failure(request, 'owner-unknown', 'RECOVERY_ORCHESTRATION_UNKNOWN', error instanceof Error ? error.message : String(error), { taskId });
+    }
+    if (!run)
+        return result(request, 'no-op', { taskId });
+    const rows = openRows(section);
+    const pending = run.pendingDelegation;
+    if (!pending) {
+        const candidates = abortedCandidates(run, rows);
+        if (candidates.length === 0)
+            return result(request, 'no-op', { taskId });
+        if (candidates.length > 1) {
+            return failure(request, 'conflict', 'RECOVERY_CANDIDATE_AMBIGUOUS', 'more than one aborted delegation has an open lifecycle row', { taskId });
+        }
+        return appendRecoveryLog(request, taskId, section, candidates[0], resolved.repoRoot, options.writeTask ?? writeTask);
+    }
+    if (pending.status !== 'activated')
+        return result(request, 'no-op', { taskId });
+    if (pending.client !== 'codex' || run.status !== 'running' || run.pause !== null) {
+        return failure(request, 'conflict', 'RECOVERY_ORCHESTRATION_INVALID', 'activated recovery requires one running Codex delegation', {
+            taskId, receiptId: pending.id, childId: pending.childId
+        });
+    }
+    const matchingRows = rowForReceipt(rows, pending);
+    if (matchingRows.length !== 1 || normalizeAgentToken(matchingRows[0].agent) !== 'codex' || matchingRows[0].note !== 'started') {
+        return failure(request, 'conflict', 'RECOVERY_LOG_CONFLICT', 'activated delegation does not have one matching open lifecycle row', {
+            taskId, receiptId: pending.id, childId: pending.childId
+        });
+    }
+    if (!pending.childId) {
+        return failure(request, 'conflict', 'RECOVERY_DELEGATION_INVALID', 'activated delegation has no child identity', { taskId, receiptId: pending.id });
+    }
+    const store = readLifecycleStore(options, resolved.repoRoot);
+    const stored = readStoredEvidence(store, pending.childId);
+    if ('error' in stored)
+        return failure(request, 'owner-unknown', 'RECOVERY_STORE_UNKNOWN', stored.error.message, { taskId, receiptId: pending.id, childId: pending.childId });
+    if ('missing' in stored)
+        return failure(request, 'owner-unknown', 'RECOVERY_STOP_EVIDENCE_MISSING', 'matching Codex lifecycle stop evidence is missing', { taskId, receiptId: pending.id, childId: pending.childId });
+    const evidence = validateStopRecord(stored, pending);
+    if (!evidence.ok)
+        return failure(request, evidence.code === 'RECOVERY_CONSUMER_CONFLICT' ? 'conflict' : 'owner-unknown', evidence.code, evidence.message, { taskId, receiptId: pending.id, childId: pending.childId });
+    let consumed = stored;
+    if (stored.consumer === null) {
+        try {
+            consumed = store.consume(pending.childId, pending.id, pending.hostEvidence?.hookDefinitionHash);
+        }
+        catch (error) {
+            return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_CONSUME_FAILED', error instanceof Error ? error.message : String(error), { taskId, receiptId: pending.id, childId: pending.childId });
+        }
+    }
+    if (!consumed.consumedAt) {
+        return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_INVALID', 'consumed stop evidence has no timestamp', { taskId, receiptId: pending.id, childId: pending.childId });
+    }
+    const recovered = recoverActivatedOrchestrationDelegationUnderLock(taskId, {
+        receiptId: pending.id,
+        stage: pending.stage,
+        round: pending.round,
+        artifact: pending.artifact,
+        startedAgent: request.agent,
+        childId: pending.childId,
+        stopRevision: consumed.revision,
+        consumer: pending.id,
+        consumedAt: consumed.consumedAt
+    }, { ...options.orchestration, repoRoot: resolved.repoRoot, now: options.now });
+    if (recovered.status === 'failed' || !recovered.run) {
+        return failure(request, 'owner-unknown', recovered.error?.code ?? 'RECOVERY_ORCHESTRATION_FAILED', recovered.error?.message ?? 'orchestration recovery failed', { taskId, receiptId: pending.id, childId: pending.childId });
+    }
+    return appendRecoveryLog(request, taskId, section, { receipt: recovered.run.receipts.at(-1), row: matchingRows[0] }, resolved.repoRoot, options.writeTask ?? writeTask);
+}
+function recoverStartedLifecycleFromAdapter(request, options = {}) {
+    return recoverStartedLifecycleUnderLock(request, options);
+}
+export { recoverStartedLifecycleFromAdapter, recoverStartedLifecycleUnderLock };
+//# sourceMappingURL=recovery.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.js

@@ -5,8 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import semver from 'semver';
 import * as toml from 'smol-toml';
-import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify, requestSandboxControl } from '../../../sandbox/control/client.js';
-import { readSandboxControlStatus } from '../../../sandbox/control/state.js';
+import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify } from '../../../sandbox/control/client.js';
 import { getProcessStartTime } from '../../../server/process-state.js';
 import { LIFECYCLE_PROTOCOL_VERSION } from './build-identity.js';
 import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings, writeCodexSandboxControllerContext } from './controller-context.js';
@@ -56,44 +55,18 @@ function verifyRuntime(runtimeDir) {
         fs.rmSync(probe, { force: true });
     }
 }
-function verifyControl(taskId, control) {
+function verifyControllerBinding(context, control, requestControllerVerify) {
     verifyRuntime(control.runtimeDir);
-    let status = null;
-    let lastError = null;
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-        try {
-            status = readSandboxControlStatus(control.statusDir);
-            break;
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt < 4)
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
-        }
-    }
-    if (!status) {
-        throw new Error(`CODEX_SANDBOX_CONTROLLER_CONTROL_UNAVAILABLE: ${String(lastError)}`);
-    }
-    if (status.generation !== control.generation
-        || status.state !== 'healthy'
-        || Date.now() - status.updatedAt > 1_500) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_UNAVAILABLE');
-    }
-    const response = requestSandboxControl({
-        family: 'task-orchestration',
-        args: [taskId, 'status'],
+    const verified = requestControllerVerify({
+        controllerProof: controllerProofFromContext(context),
         ...control,
         timeoutMs: 30_000
     });
-    let payload = {};
-    try {
-        payload = JSON.parse(response.stdout);
-    }
-    catch {
+    if (verified.binding.taskId !== context.taskId
+        || verified.binding.controlGeneration !== context.controlGeneration
+        || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
         throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
     }
-    if (payload.taskId !== taskId)
-        throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
 function verifyCodexSandboxControllerContextWithWarnings(contextPath, options = {}) {
     const control = options.control ?? controlFromEnvironment();
@@ -272,7 +245,7 @@ function prepareCodexSandboxController(input, options = {}) {
             || opened.lease.controllerProcess.startTime !== parentStartTime) {
             throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
         }
-        (options.verifyTaskBinding ?? verifyControl)(taskId, control);
+        verifyControllerBinding(context, control, options.verifyController ?? requestCodexControllerVerify);
         const contextPath = path.join(home, 'controller-context.json');
         writeCodexSandboxControllerContext(contextPath, context);
         const shimDir = path.join(home, 'bin');

package/dist/lib/agent-clients/adapters/codex-lifecycle/store.js

@@ -6,19 +6,9 @@ import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js'
 const LOCK_RETRY_MS = 10;
 const LOCK_TIMEOUT_MS = 1_000;
 const LOCK_STALE_MS = 30_000;
-const RECOVERY_CONSUMER_RE = /^lifecycle-recovery:([^:\r\n]+):([^:\r\n]+)$/u;
 function digest(value) {
     return crypto.createHash('sha256').update(value).digest('hex');
 }
-function isRecoveryConsumer(value) {
-    return RECOVERY_CONSUMER_RE.test(value);
-}
-function recoveryConsumer(taskId, receiptId) {
-    if (!/^[^:\r\n]+$/u.test(taskId) || !/^[^:\r\n]+$/u.test(receiptId)) {
-        throw new Error('Codex lifecycle recovery claim identity is invalid');
-    }
-    return `lifecycle-recovery:${taskId}:${receiptId}`;
-}
 function readRecord(file) {
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (value.schemaVersion !== 1
@@ -255,29 +245,8 @@ function createCodexLifecycleStore(options) {
     function consume(childThreadId, consumer, expectedHookDefinitionHash) {
         if (!consumer.trim())
             throw new Error('Codex lifecycle consumer is required');
-        if (consumer.startsWith('lifecycle-recovery:')) {
-            throw new Error('Codex lifecycle recovery claims require claimRecovery');
-        }
         return consumeInternal(childThreadId, consumer, expectedHookDefinitionHash);
     }
-    function claimRecovery(childThreadId, taskId, receiptId, expectedHookDefinitionHash) {
-        return consumeInternal(childThreadId, recoveryConsumer(taskId, receiptId), expectedHookDefinitionHash);
-    }
-    function releaseRecovery(childThreadId, consumer) {
-        if (!/^lifecycle-recovery:[^:\r\n]+:[^:\r\n]+$/.test(consumer))
-            return false;
-        return withWriteLock(() => {
-            const matches = findByChild(childThreadId);
-            if (matches.length !== 1)
-                return false;
-            const file = matches[0];
-            const current = readRecord(file);
-            if (current.state.status !== 'stop-ready' || current.consumer !== consumer || !current.consumedAt)
-                return false;
-            fs.unlinkSync(file);
-            return true;
-        });
-    }
     function expireBefore(cutoff) {
         return withWriteLock(() => {
             let changed = 0;
@@ -285,8 +254,6 @@ function createCodexLifecycleStore(options) {
                 const current = readRecord(file);
                 if (current.updatedAt >= cutoff)
                     continue;
-                if (current.consumer && isRecoveryConsumer(current.consumer))
-                    continue;
                 if (current.consumer || ['invalid', 'expired', 'stop-ready'].includes(current.state.status)) {
                     fs.unlinkSync(file);
                     changed += 1;
@@ -306,7 +273,7 @@ function createCodexLifecycleStore(options) {
             return changed;
         });
     }
-    return Object.freeze({ root, apply, applyToSpawn, consume, claimRecovery, releaseRecovery, expireBefore, findByParent, read });
+    return Object.freeze({ root, apply, applyToSpawn, consume, expireBefore, findByParent, read });
 }
 export { createCodexLifecycleStore, hasActiveCodexLifecycleEvidence };
 //# sourceMappingURL=store.js.map

package/dist/lib/agent-clients/adapters/codex.js

@@ -24,6 +24,16 @@ const codexAdapter = defineAgentClientAdapter({
         actualModel: 'app-server',
         actualReasoningEffort: 'app-server'
     },
+    orchestrationAdapter: {
+        prepareDelegation: async (...args) => {
+            const { prepareCodexOrchestrationDelegation } = await import('../../task/codex-orchestration.js');
+            return prepareCodexOrchestrationDelegation(...args);
+        },
+        recoverStarted: async (...args) => {
+            const { recoverStartedLifecycleFromAdapter } = await import('./codex-lifecycle/recovery.js');
+            return recoverStartedLifecycleFromAdapter(...args);
+        }
+    },
     project: {
         ownedPathPrefixes: ['.codex/'],
         managed: ['.codex/hooks.json', '.codex/agents/'],

package/dist/lib/internal/cli-route-inventory.js

@@ -43,7 +43,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', 'recover', 'owner', 'backfill', 'sync'],
+    'platform-comment': ['list', 'recover', 'owner', 'backfill', 'stage-summary', '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'],

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

@@ -5,7 +5,7 @@ import { resolveTaskRef } from '../task/resolve-ref.js';
 import { applyTaskEvent } from '../task/events.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
-import { createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, readManualValidationReceipt, writeManualValidationReceiptAtomic } from '../task/manual-validation-receipt.js';
+import { MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, 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';
@@ -22,28 +22,22 @@ function printFailure(format, error) {
         process.stderr.write(`${error.code}: ${error.message}\n`);
     process.exitCode = 1;
 }
-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, phase, transactionId, receiptDigest = '', evidenceDigest = '', prHeadSha = '') {
+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 section = phase === 'pending'
-        ? chinese
-            ? `### ⏳ 人工验证待收尾\n\n人工验证证据已暂存；事务 ${transactionId} 正在等待最终完成。`
-            : `### ⏳ Manual Validation Pending\n\nManual validation evidence is staged; transaction ${transactionId} is awaiting final promotion.`
-        : chinese
-            ? `### ✅ 人工验证已通过\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, (matched) => {
-        if (inserted)
-            return '';
-        inserted = true;
-        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`;
+    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`;
 }
 function openManualValidationStarted(taskMdPath) {
     let content;
@@ -102,7 +96,9 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
     const pullRequest = currentState.pullRequest;
     const preimageBody = currentState.comment?.body ?? '';
     const preimage = { commentId: currentState.comment?.id ?? null, body: preimageBody, digest: summaryPreimageDigest(preimageBody) };
-    const evidenceDigest = sha256File(path.resolve(cwd, values.summaryFile));
+    const summaryPath = path.resolve(cwd, values.summaryFile);
+    const finalBodyWithoutReceipt = fs.readFileSync(summaryPath, '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 });
     let previousTransaction = null;
@@ -135,8 +131,7 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
     const transactionId = transactionResult.ok
         ? transactionResult.value.transactionId
         : (openStarted.transactionId ?? values.transactionId ?? `mv-${Date.now()}`);
-    const finalBodyWithoutReceipt = fs.readFileSync(path.resolve(cwd, values.summaryFile), 'utf8');
-    const pendingBody = manualSummaryBody(finalBodyWithoutReceipt, 'pending', transactionId);
+    const pendingBody = manualSummaryBody(finalBodyWithoutReceipt, 'pending');
     const createTransaction = () => createManualValidationTransaction({
         transactionId,
         taskId: resolved.taskId,
@@ -145,7 +140,7 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
         evidenceDigest,
         summaryPreimage: preimage,
         pendingSummaryDigest: summaryPreimageDigest(pendingBody),
-        finalSummaryDigest: manualValidationFinalSummaryDigest(manualSummaryBody(finalBodyWithoutReceipt, 'final', transactionId, '<receipt>', evidenceDigest, pullRequest.head.sha)),
+        finalSummaryDigest: manualValidationFinalSummaryDigest(manualSummaryBody(finalBodyWithoutReceipt, 'final')),
         artifact: values.artifact,
         attempt: 1,
         createdAt: new Date().toISOString(),
@@ -249,7 +244,7 @@ async function executeManualValidationTransactionLocked(taskRef, values, cwd, re
             transitionAndPersist('final-promotion-in-progress');
         }
         const promoted = await syncPullRequestSummary(taskRef, {
-            cwd, client: options.client, agent, body: manualSummaryBody(finalBodyWithoutReceipt, 'final', transaction.transactionId, receipt.receiptDigest, receipt.evidenceDigest, receipt.prHeadSha), changeReportFile: path.resolve(cwd, values.changeReportFile), primaryResult, strict: true,
+            cwd, client: options.client, agent, body: manualSummaryBody(finalBodyWithoutReceipt, 'final'), changeReportFile: path.resolve(cwd, values.changeReportFile), primaryResult, strict: true,
             manualValidation: { phase: 'final', transactionId: transaction.transactionId, receiptDigest: receipt.receiptDigest, prHeadSha: receipt.prHeadSha, authority: 'coordinator' }, lockAlreadyHeld: true
         });
         if (!['applied', 'no-op'].includes(promoted.status))

package/dist/lib/internal/platform-comment.js

@@ -1,14 +1,19 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { checkPlatformCommentOwner, listPlatformComments, syncPlatformComment } from '../platform/issue-comments.js';
+import { canonicalizeSummaryBody } from '../platform/comment-safety.js';
+import { platformResult } from '../platform/types.js';
 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';
 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 stage-summary <task-ref> --body-file <path|-> [--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>]
 `;
 function fail(message) {
@@ -63,6 +68,7 @@ async function platformComment(args = []) {
         internalHandlerRoute('platform-comment', 'recover', operation),
         internalHandlerRoute('platform-comment', 'owner', operation),
         internalHandlerRoute('platform-comment', 'backfill', operation),
+        internalHandlerRoute('platform-comment', 'stage-summary', operation),
         internalHandlerRoute('platform-comment', 'sync', operation)
     ].some(Boolean)) {
         fail('a valid operation is required');
@@ -177,6 +183,59 @@ async function platformComment(args = []) {
         finish(await backfillCompletionComments(taskRef, { cwd, agent: normalizedAgent }));
         return;
     }
+    if (internalHandlerRoute('platform-comment', 'stage-summary', operation)) {
+        const unexpected = Object.keys(parsed.values).find((key) => !['cwd', 'bodyFile'].includes(key));
+        if (unexpected) {
+            fail(`stage-summary does not accept '--${unexpected}'`);
+            return;
+        }
+        if (typeof parsed.values.bodyFile !== 'string') {
+            fail('stage-summary requires --body-file');
+            return;
+        }
+        let body;
+        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') };
+        const previous = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : null;
+        const next = `${JSON.stringify(value)}\n`;
+        if (previous === next) {
+            finish(platformResult('no-op'));
+            return;
+        }
+        const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            fs.writeFileSync(temporary, next, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+            fs.renameSync(temporary, target);
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(temporary);
+            }
+            catch { /* preserve primary error */ }
+            fail(`unable to stage summary: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        finish(platformResult('applied', { operations: [{ name: 'delivery-summary', status: 'applied', reasonCode: null }] }));
+        return;
+    }
     if (!internalHandlerRoute('platform-comment', 'sync', operation)) {
         fail('operation is not registered');
         return;