@fitlab-ai/agent-infra 0.12.0 → 0.12.1

package/dist/lib/platform/summary-content-pipeline.js

@@ -0,0 +1,18 @@
+function parse(value, parser) {
+    try {
+        return parser(value);
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+export function runSummaryContentPipeline(value, operations) {
+    try {
+        parse(value, operations.validate);
+    }
+    catch { /* Source correction gets a chance to repair invalid structure. */ }
+    const corrected = operations.correct(value);
+    const content = parse(corrected, operations.validate);
+    return { content, rendered: operations.render(content) };
+}
+//# sourceMappingURL=summary-content-pipeline.js.map

package/dist/lib/sandbox/removal.js

@@ -27,6 +27,40 @@ function isMissingPathError(error) {
     return Boolean(error && typeof error === 'object' && 'code' in error
         && error.code === 'ENOENT');
 }
+function removalErrorCode(error) {
+    return error && typeof error === 'object' && 'code' in error
+        && typeof error.code === 'string'
+        ? error.code
+        : null;
+}
+function removalErrorMessage(error) {
+    const code = removalErrorCode(error);
+    const message = error instanceof Error ? error.message : String(error);
+    return code ? `${code}: ${message}` : message;
+}
+function addOwnerWriteToDirectories(root) {
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        let stat;
+        try {
+            stat = fs.lstatSync(current);
+        }
+        catch (error) {
+            if (isMissingPathError(error))
+                continue;
+            throw error;
+        }
+        if (!stat.isDirectory())
+            continue;
+        fs.chmodSync(current, stat.mode | 0o200);
+        for (const entry of fs.readdirSync(current))
+            pending.push(path.join(current, entry));
+    }
+}
+function isPermissionRemovalError(error) {
+    return ['EACCES', 'EPERM', 'ENOTEMPTY'].includes(removalErrorCode(error) ?? '');
+}
 function canonicalPath(input) {
     try {
         return fs.realpathSync.native(input);
@@ -718,8 +752,28 @@ async function removeUncheckedSandbox(config, target, options) {
         fs.rmSync(root, { recursive: true, force: true });
         removeEmptyManagedParent(path.join(config.workspaceViewBase, config.project), root);
     }
-    for (const candidate of toolCandidates.flatMap(({ candidates }) => candidates))
-        fs.rmSync(candidate, { recursive: true, force: true });
+    const toolRemovalFailures = [];
+    for (const candidate of toolCandidates.flatMap(({ candidates }) => candidates)) {
+        try {
+            fs.rmSync(candidate, { recursive: true, force: true });
+            continue;
+        }
+        catch (initialError) {
+            if (isPermissionRemovalError(initialError)) {
+                try {
+                    addOwnerWriteToDirectories(candidate);
+                    fs.rmSync(candidate, { recursive: true, force: true });
+                    continue;
+                }
+                catch (retryError) {
+                    toolRemovalFailures.push(`${candidate}: ${removalErrorMessage(initialError)}; retry failed: ${removalErrorMessage(retryError)}`);
+                }
+            }
+            else {
+                toolRemovalFailures.push(`${candidate}: ${removalErrorMessage(initialError)}`);
+            }
+        }
+    }
     for (const shell of shellConfigDirCandidates(config, effectiveBranch))
         fs.rmSync(shell, { recursive: true, force: true });
     if (shouldRemoveShare)
@@ -736,6 +790,9 @@ async function removeUncheckedSandbox(config, target, options) {
         assertBranchRemovalIdentity(config, effectiveBranch, worktreePermits);
         runSafe('git', ['-C', config.repoRoot, 'branch', '-D', effectiveBranch]);
     }
+    if (toolRemovalFailures.length > 0) {
+        throw new Error(`SANDBOX_TOOL_CLEANUP_INCOMPLETE:\n${toolRemovalFailures.map((failure) => `  - ${failure}`).join('\n')}`);
+    }
     releaseTaskBoundSandboxIdentity(config.repoRoot, target.workspace);
     if (!options.quiet)
         p.outro('Sandbox removed');

package/dist/lib/task/finalization.js

@@ -17,6 +17,7 @@ import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
 import { readSandboxControlManifest } from '../sandbox/control/lifecycle.js';
 import { validateSandboxControlIdentity } from '../sandbox/control/identity-sentinel.js';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent } from '../platform/issue-summary-content.js';
 const RECEIPT_VERSION = 4;
 const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'];
 export function resolveTaskFinalizationDirectory(repoRoot, taskId) {
@@ -569,17 +570,25 @@ function readDeliverySummary(taskDir, taskId) {
     catch {
         throw Object.assign(new Error('delivery summary staging record is unavailable'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    if (value.taskId !== taskId || typeof value.body !== 'string' || typeof value.sha256 !== 'string') {
+    if (value.taskId !== taskId || !value.content || typeof value.contentSha256 !== 'string') {
         throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    const canonical = canonicalizeSummaryBody(value.body);
-    if (!canonical.ok || canonical.value !== value.body) {
-        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+    let content;
+    try {
+        content = parseDeliverySummaryContent(value.content);
+    }
+    catch {
+        throw Object.assign(new Error('delivery summary staging payload is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
+    }
+    if (content.taskId !== taskId || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== value.contentSha256) {
+        throw Object.assign(new Error('delivery summary staging digest does not match payload'), { code: 'SUMMARY_STAGING_INVALID' });
     }
+    const body = renderDeliverySummaryContent(content);
+    const canonical = canonicalizeSummaryBody(body);
+    if (!canonical.ok)
+        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
     const digest = createHash('sha256').update(canonical.value).digest('hex');
-    if (digest !== value.sha256)
-        throw Object.assign(new Error('delivery summary staging digest does not match body'), { code: 'SUMMARY_STAGING_INVALID' });
-    return { body: canonical.value, sha256: value.sha256 };
+    return { body: canonical.value, sha256: digest };
 }
 async function syncPendingSummary(input) {
     let { receipt } = input;

package/dist/lib/task/platform-operation-recovery.js

@@ -2,13 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { inspectPlatformCommentOperation, normalizeCommentContent, syncPlatformComment } from '../platform/issue-comments.js';
+import { inspectPlatformCommentOperation, syncPlatformComment } from '../platform/issue-comments.js';
+import { parseDeliverySummaryContent, renderDeliverySummaryContent, parseCancelSummaryContent, renderCancelSummaryContent } from '../platform/issue-summary-content.js';
+import { enumerateArtifacts } from './artifacts.js';
 import { inspectPlatformIssue, syncPlatformIssue } from '../platform/issues.js';
 import { resolvePlatformProviderContext } from '../platform/context.js';
 import { providerOperationContext, providerError, unsupportedProviderOperation } from '../platform/provider-bridge.js';
 import { inLabelMappingDigest } from '../platform/in-label-sync.js';
-import { bindPlatformPullRequest, inspectPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
-import { syncPullRequestSummary } from '../platform/pr-summary.js';
+import { bindPlatformPullRequest, recoverCreatedPullRequest, syncPlatformPullRequest } from '../platform/pull-requests.js';
+import { replayPullRequestSummary } from '../platform/pr-summary.js';
 import { publishPrReview, readReviewBodyFile } from '../platform/pr-review.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
@@ -35,32 +37,70 @@ function summaryPayload(taskDir, taskId) {
     if (!fs.existsSync(file))
         return null;
     const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const canonical = typeof data.body === 'string' ? canonicalizeSummaryBody(data.body) : null;
-    if (data.taskId !== taskId || typeof data.body !== 'string' || typeof data.sha256 !== 'string'
-        || !canonical?.ok || canonical.value !== data.body
-        || createHash('sha256').update(data.body).digest('hex') !== data.sha256) {
+    let content;
+    try {
+        content = parseDeliverySummaryContent(data.content);
+    }
+    catch {
+        content = null;
+    }
+    if (data.taskId !== taskId || !content || content.taskId !== taskId || typeof data.contentSha256 !== 'string'
+        || createHash('sha256').update(JSON.stringify(content)).digest('hex') !== data.contentSha256) {
         throw Object.assign(new Error('delivery summary staging record is invalid'), { code: 'SUMMARY_STAGING_INVALID' });
     }
-    return { body: data.body, sha256: data.sha256 };
+    const canonical = canonicalizeSummaryBody(renderDeliverySummaryContent(content));
+    if (!canonical?.ok)
+        throw Object.assign(new Error('delivery summary staging body is not canonical'), { code: 'SUMMARY_STAGING_INVALID' });
+    return { body: canonical.value, sha256: createHash('sha256').update(canonical.value).digest('hex') };
+}
+function cancellationPayload(taskDir, taskId) {
+    const taskPath = path.join(taskDir, 'task.md');
+    if (!fs.existsSync(taskPath))
+        return null;
+    const taskContent = fs.readFileSync(taskPath, 'utf8');
+    const frontmatter = parseTaskFrontmatter(taskContent);
+    const title = /^#\s+(.+)$/mu.exec(taskContent)?.[1]?.trim() || taskId;
+    const artifacts = enumerateArtifacts(taskDir).filter((artifact) => artifact.name !== 'task.md').map((artifact) => artifact.name);
+    const content = parseCancelSummaryContent({
+        taskId,
+        title,
+        outcome: 'cancelled',
+        reason: frontmatter.cancel_reason,
+        cancelledAt: frontmatter.cancelled_at,
+        lastCompletedArtifact: artifacts.at(-1) ?? null
+    });
+    return renderCancelSummaryContent(content);
 }
 async function replayComment(taskId, taskDir, operation, agent, cwd, client) {
     if (operation.kind === 'task-comment') {
-        return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        return syncPlatformComment(taskId, { kind: 'task', agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'artifact-comment') {
-        return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        return syncPlatformComment(taskId, { kind: 'artifact', artifact: operation.target, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'summary-comment') {
-        const summary = summaryPayload(taskDir, taskId);
+        let summary;
+        try {
+            summary = summaryPayload(taskDir, taskId);
+        }
+        catch (error) {
+            return platformResult('failed', { error: { code: 'SUMMARY_STAGING_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+        }
         if (!summary)
-            return platformResult('failed', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: false } });
-        return syncPlatformComment(taskId, {
-            kind: 'summary', body: summary.body, agent, cwd,
-            summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, client, skipQueue: true
-        });
+            return platformResult('blocked', { error: { code: 'SUMMARY_STAGING_MISSING', message: 'delivery summary staging record is unavailable', retryable: true } });
+        return syncPlatformComment(taskId, { kind: 'summary', body: summary.body, agent, cwd, client, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency, queuedOperation: operation });
     }
     if (operation.kind === 'cancel-comment') {
-        return syncPlatformComment(taskId, { kind: 'cancel', agent, cwd, client, dependency: operation.dependency, skipQueue: true });
+        let body;
+        try {
+            body = cancellationPayload(taskDir, taskId);
+        }
+        catch (error) {
+            return platformResult('failed', { error: { code: 'CANCEL_SUMMARY_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+        }
+        if (!body)
+            return platformResult('blocked', { error: { code: 'CANCEL_SUMMARY_INVALID', message: 'Cancellation facts are unavailable for recovery', retryable: true } });
+        return syncPlatformComment(taskId, { kind: 'cancel', body, agent, cwd, client, dependency: operation.dependency, queuedOperation: operation });
     }
     return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_UNSUPPORTED', message: `operation kind '${operation.kind}' has no registered recovery handler`, retryable: false } });
 }
@@ -185,64 +225,6 @@ async function verifyIssueCreate(taskId, operation, cwd, client) {
             } });
     return platformResult('no-op');
 }
-async function replayPullRequestSummary(taskId, operation, agent, cwd, client) {
-    let identity;
-    try {
-        identity = parseResourceIdentity(JSON.parse(operation.target), 'queued pull-request summary identity');
-    }
-    catch {
-        return platformResult('failed', { error: { code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Queued pull-request summary identity is invalid', retryable: false } });
-    }
-    const summary = operation.pullRequestSummary;
-    if (!summary)
-        return platformResult('blocked', { error: {
-                code: 'PLATFORM_OPERATION_PAYLOAD_INVALID', message: 'Pull-request summary recovery content is missing', retryable: false
-            } });
-    const manualValidationHeading = /^###\s+(?:⏳\s+(?:Manual Validation Pending|人工验证待收尾)|✅\s+(?:Manual Validation Passed|人工验证已通过))\s*$/mu.test(summary.body);
-    if (manualValidationHeading && !summary.manualValidation)
-        return platformResult('blocked', { error: {
-                code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'Queued manual-validation summary has no persisted transaction context', retryable: false
-            } });
-    const resolved = await resolvePlatformProviderContext({ cwd, client });
-    if (!resolved.ok)
-        return resolved.context;
-    const listed = resolved.value.provider.comments?.list
-        ? await resolved.value.provider.comments.list({ context: providerOperationContext(resolved.value), parent: identity })
-        : unsupportedProviderOperation(resolved.value.provider, 'comments.list');
-    if (!listed.ok)
-        return platformResult(providerErrorRetryable(listed.error.code) ? 'blocked' : 'failed', { error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') });
-    const marker = `<!-- sync-pr:${taskId}:summary -->`;
-    const summaries = listed.value.filter((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === marker);
-    if (summaries.length > 1)
-        return platformResult('blocked', { error: {
-                code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple pull-request comments contain the queued summary marker', retryable: false
-            } });
-    if (!summary.manualValidation && summaries.length === 1 && createHash('sha256').update(normalizeCommentContent(summaries[0].body)).digest('hex') === operation.expectedDigest) {
-        return platformResult('no-op');
-    }
-    const bound = await inspectPlatformPullRequest(taskId, { cwd, client });
-    if (!bound.pullRequest || !resourceIdentityEquals(bound.pullRequest.identity, identity))
-        return platformResult('blocked', { error: bound.error ?? {
-                code: 'PLATFORM_OPERATION_IDENTITY_MISMATCH', message: 'Bound pull request differs from the queued summary target', retryable: false
-            } });
-    const replayed = await syncPullRequestSummary(taskId, {
-        agent,
-        cwd,
-        client,
-        body: summary.body,
-        changeReportFile: summary.changeReportFile,
-        ...(summary.manualValidation ? { manualValidation: summary.manualValidation } : {}),
-        primaryResult: 'no_op',
-        strict: true,
-        skipQueue: true
-    });
-    if ((replayed.status === 'applied' || replayed.status === 'no-op') && !replayed.error && replayed.warnings.length === 0) {
-        return platformResult(replayed.status, { changed: replayed.changed });
-    }
-    return platformResult('blocked', { error: replayed.error ?? {
-            code: 'PR_SUMMARY_RECOVERY_UNCONFIRMED', message: 'Pull-request summary replay did not confirm the requested remote state', retryable: true
-        } });
-}
 async function replayPullRequestReview(operation, agent, cwd, client) {
     const intent = operation.pullRequestReview;
     if (!intent)
@@ -301,6 +283,14 @@ async function replayPullRequest(taskId, operation, agent, cwd) {
     }
     return recoverCreatedPullRequest(taskId, { agent, cwd, base: intent.baseRef || '', head: intent.headRef || '', skipQueue: true });
 }
+function isRecoveryEligible(operation, excludeId) {
+    if (operation.id === excludeId)
+        return false;
+    if (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown')
+        return true;
+    return operation.state === 'failed'
+        && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED';
+}
 async function recoverPlatformOperationsOnce(taskRef, selection, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -313,9 +303,7 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
         const value = error;
         return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
     }
-    const candidates = journal.operations.filter((operation) => operation.id !== options.excludeId
-        && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED')));
+    const candidates = journal.operations.filter((operation) => isRecoveryEligible(operation, options.excludeId));
     if (!candidates.length)
         return result('no-op', [], []);
     const head = candidates[0];
@@ -382,9 +370,22 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 : operation.kind === 'artifact-comment'
                     ? { kind: 'artifact', artifact: operation.target, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency }
                     : operation.kind === 'summary-comment' ? (() => {
-                        const summary = summaryPayload(resolved.taskDir, resolved.taskId);
-                        return summary ? { kind: 'summary', body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
-                    })() : { kind: 'cancel', agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency };
+                        try {
+                            const summary = summaryPayload(resolved.taskDir, resolved.taskId);
+                            return summary ? { kind: 'summary', body: summary.body, agent: options.agent, cwd: resolved.repoRoot, summaryAuthorization: { sha256: summary.sha256 }, dependency: operation.dependency } : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    })() : (() => {
+                        try {
+                            const body = cancellationPayload(resolved.taskDir, resolved.taskId);
+                            return body ? { kind: 'cancel', body, agent: options.agent, cwd: resolved.repoRoot, dependency: operation.dependency } : null;
+                        }
+                        catch {
+                            return null;
+                        }
+                    })();
             const current = commentOptions ? inspectPlatformCommentOperation(resolved.taskId, commentOptions) : null;
             if (!current) {
                 pending.push(operation.id);
@@ -407,20 +408,21 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
             remote = operation.kind === 'issue-create'
                 ? await verifyIssueCreate(resolved.taskId, operation, resolved.repoRoot)
                 : operation.kind === 'pull-request-summary'
-                    ? await replayPullRequestSummary(resolved.taskId, operation, options.agent, resolved.repoRoot, options.client)
+                    ? await replayPullRequestSummary(resolved.taskId, targetOperation, { agent: options.agent, cwd: resolved.repoRoot, client: options.client })
                     : operation.kind === 'pull-request-review'
                         ? await replayPullRequestReview(operation, options.agent, resolved.repoRoot, options.client)
                         : operation.kind === 'issue-metadata'
                             ? await replayIssueMetadata(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
                             : operation.kind === 'pull-request'
                                 ? await replayPullRequest(resolved.taskId, targetOperation, options.agent, resolved.repoRoot)
-                                : await replayComment(resolved.taskId, resolved.taskDir, operation, options.agent, resolved.repoRoot);
+                                : await replayComment(resolved.taskId, resolved.taskDir, targetOperation, options.agent, resolved.repoRoot, options.client);
         }
         catch (error) {
             const value = error;
             remote = platformResult('blocked', { error: { code: value.code || 'PLATFORM_OPERATION_RECOVERY_FAILED', message: value.message || String(error), retryable: true } });
         }
         const succeeded = (remote.status === 'applied' || remote.status === 'no-op') && !remote.error;
+        const latestOperation = readPlatformOperationJournal(resolved.taskId, resolved.repoRoot).operations.find((item) => item.id === operation.id);
         try {
             recordPlatformOperation({
                 taskRef: resolved.taskId,
@@ -435,7 +437,7 @@ async function recoverPlatformOperationsOnce(taskRef, selection, options) {
                 ...(operation.pullRequestReview ? { pullRequestReview: operation.pullRequestReview } : {}),
                 dependency: operation.dependency,
                 state: succeeded ? 'succeeded' : 'unknown',
-                lastCode: remote.error?.code ?? null
+                lastCode: remote.error?.code ?? latestOperation?.lastCode ?? null
             });
         }
         catch (error) {
@@ -464,9 +466,7 @@ async function recoverPlatformOperations(taskRef, selection, options) {
         const value = error;
         return result('failed', [], [], { code: value.code || 'PLATFORM_OPERATION_JOURNAL_INVALID', message: value.message || String(error), retryable: false });
     }
-    const eligible = (operation) => operation.id !== options.excludeId
-        && (operation.state === 'queued' || operation.state === 'pending' || operation.state === 'unknown'
-            || (operation.state === 'failed' && operation.lastCode !== 'PLATFORM_OPERATION_SUPERSEDED'));
+    const eligible = (operation) => isRecoveryEligible(operation, options.excludeId);
     const first = initial.operations.filter(eligible);
     if (!first.length)
         return result('no-op', [], []);

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.12.0",
-  "sourceInputHash": "c0a3da802ab0d992591d4ddd191550627992e7f76fea444bab99f342bd59ec18",
-  "internalExecutableBuildHash": "536ccdede573b4204982cb184b9b0f5ad8c3f943f3d1e749b42ed05bbcca9ead"
+  "packageVersion": "0.12.1",
+  "sourceInputHash": "b998fe9d348d3f7f55e1258d2d09793f09240d1d70173d6bce49a9ce6c89429e",
+  "internalExecutableBuildHash": "d75b6e06c5ed88b0cd03663d98e2001c3f5c661d9637b8e6b8993580f69a3f16"
 }

package/lib/internal/manual-validation.ts

@@ -3,9 +3,10 @@ import path from 'node:path';
 
 import { locateActivityLog, pairEntries } from '../task/activity-log.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,23 +43,15 @@ 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 } {
@@ -112,6 +105,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! });
@@ -146,7 +140,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(),

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,