@fitlab-ai/agent-infra 0.11.1 → 0.11.3

package/dist/lib/internal/sandbox-control.js

@@ -1,118 +1,9 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, requestSandboxTaskControl, requestSandboxTaskWorkflow, resolveVisibleActiveShortId, SandboxControlClientError } from '../sandbox/control/client.js';
+import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
-import { controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.js';
-import { createTaskWorkflowRequest } from '../sandbox/control/task-workflow.js';
-import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
-import { routeOrchestration } from '../task/orchestration.js';
-import { parseArtifactName } from '../task/artifact-name.js';
-function valueAfter(args, flag) {
-    for (let index = 0; index < args.length; index += 1) {
-        if (args[index] === flag)
-            return args[index + 1];
-        if (args[index]?.startsWith(`${flag}=`))
-            return args[index].slice(flag.length + 1);
-    }
-    return undefined;
-}
-function withoutValue(args, flag) {
-    const result = [];
-    for (let index = 0; index < args.length; index += 1) {
-        if (args[index] === flag) {
-            index += 1;
-            continue;
-        }
-        if (args[index]?.startsWith(`${flag}=`))
-            continue;
-        result.push(args[index]);
-    }
-    return result;
-}
-function lifecycleIds(authorityRef, taskId) {
-    const digest = (label) => createHash('sha256')
-        .update(`${label}\0${taskId}\0${authorityRef}`, 'utf8')
-        .digest('hex');
-    return { operationId: digest('operation'), lifecycleRequestId: digest('lifecycle-request') };
-}
-function lifecycleAuthorityIdentity(authorityRef, taskId, requestId, phase, family, artifact, round) {
-    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-    if (!authorityRef || !contextPath)
-        return undefined;
-    const routed = verifyCodexSandboxControllerContextWithWarnings(contextPath, { repoRoot: process.cwd() });
-    const buildIdentity = computeLifecycleBuildIdentity(process.cwd());
-    const hookDefinitionHash = createHash('sha256')
-        .update(readFileSync(path.join(process.cwd(), '.codex', 'hooks.json')))
-        .digest('hex');
-    const ids = lifecycleIds(authorityRef, taskId);
-    return {
-        version: 1,
-        requestId,
-        operationId: ids.operationId,
-        phase,
-        taskId,
-        family,
-        artifact,
-        round,
-        lifecycleRequestId: ids.lifecycleRequestId,
-        authorityRef,
-        expectedControlGeneration: routed.context.controlGeneration,
-        expectedControllerInstanceDigest: routed.context.controllerInstanceDigest,
-        expectedBuildIdentityDigest: createHash('sha256').update(JSON.stringify(buildIdentity)).digest('hex'),
-        expectedHookDefinitionHash: hookDefinitionHash
-    };
-}
-function lifecycleAuthoritySelector(args) {
-    if (!isCanonicalCodexPrepare(args))
-        return undefined;
-    const authorityRef = valueAfter(args, '--capability-ref');
-    const taskId = args[0];
-    if (!authorityRef || !taskId)
-        return undefined;
-    const routed = routeOrchestration(taskId);
-    if (!routed.next || !['analysis', 'plan', 'code'].includes(routed.next.stage))
-        return undefined;
-    return lifecycleAuthorityIdentity(authorityRef, taskId, randomUUID(), 'orchestration.prepare', routed.next.stage === 'analysis' ? 'analysis' : routed.next.stage === 'plan' ? 'plan' : 'code', routed.next.artifact, routed.next.round);
-}
-function lifecycleWorkflowAuthoritySelector(originalArgs, workflow) {
-    const authorityRef = valueAfter(originalArgs, '--capability-ref');
-    if (!authorityRef)
-        return undefined;
-    if (workflow.operation === 'artifact-finalize-local') {
-        const family = valueAfter(workflow.args, '--family');
-        const artifact = valueAfter(workflow.args, '--artifact');
-        const parsed = artifact ? parseArtifactName(artifact) : null;
-        if ((family !== 'analysis' && family !== 'plan' && family !== 'code')
-            || !parsed || parsed.family !== family)
-            return undefined;
-        return lifecycleAuthorityIdentity(authorityRef, workflow.taskId, workflow.id, 'artifact.finalize-local', family, artifact, parsed.round);
-    }
-    if (workflow.operation !== 'event')
-        return undefined;
-    const completed = /^(analysis|plan|code)\.completed$/u.exec(workflow.args[1] ?? '');
-    const artifact = valueAfter(workflow.args, '--artifact');
-    const parsed = artifact ? parseArtifactName(artifact) : null;
-    if (!completed || !parsed || parsed.family !== completed[1])
-        return undefined;
-    return lifecycleAuthorityIdentity(authorityRef, workflow.taskId, workflow.id, 'task-event.completed', completed[1], artifact, parsed.round);
-}
-function isCanonicalCodexPrepare(args) {
-    if (args[1] !== 'prepare')
-        return false;
-    const clients = [];
-    for (let index = 2; index < args.length; index += 1) {
-        if (args[index] === '--client')
-            clients.push(args[index + 1] ?? '');
-        else if (args[index]?.startsWith('--client='))
-            clients.push(args[index].slice('--client='.length));
-    }
-    return clients.length === 1 && clients[0] === 'codex';
-}
 function writeFinalizationEnvelope(status, accepted, error, changed = false, result = null) {
     process.stdout.write(`${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`);
 }
@@ -240,69 +131,9 @@ async function sandboxControl(args) {
             sandboxFinalizationClient(commandArgs);
             return;
         }
-        if (family === 'task-workflow') {
-            const command = commandArgs[0];
-            const taskId = process.env.AGENT_INFRA_TASK_ID;
-            const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
-            if (!command || !taskId || !generation) {
-                process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'SANDBOX_CONTROL_REQUEST_INVALID', message: 'task-workflow requires a bound task and generation' } })}\n`);
-                process.exitCode = 1;
-                return;
-            }
-            let workflow;
-            try {
-                const args = withoutValue(commandArgs.slice(1), '--capability-ref');
-                if (/^\d+$/.test(args[0] ?? '')) {
-                    const resolved = resolveVisibleActiveShortId(args[0]);
-                    if (resolved !== taskId)
-                        throw new Error('SANDBOX_TASK_REF_MISMATCH');
-                    args[0] = resolved;
-                }
-                workflow = createTaskWorkflowRequest(command, args, taskId, generation);
-            }
-            catch (error) {
-                process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'SANDBOX_CONTROL_REQUEST_INVALID', message: error instanceof Error ? error.message : String(error) } })}\n`);
-                process.exitCode = 1;
-                return;
-            }
-            let response;
-            try {
-                const authority = lifecycleWorkflowAuthoritySelector(commandArgs, workflow);
-                response = requestSandboxTaskWorkflow({
-                    workflow,
-                    ...(authority ? { authority } : {})
-                });
-            }
-            catch (error) {
-                if (!(error instanceof SandboxControlClientError))
-                    throw error;
-                writeClientError(error);
-                process.exitCode = error.detail.retryable ? 75 : 1;
-                return;
-            }
-            process.stdout.write(response.stdout);
-            process.stderr.write(response.stderr);
-            process.exitCode = response.phase === 'rejected' ? response.error?.retryable ? 75 : 1 : response.exitCode ?? 1;
-            return;
-        }
         let response;
         try {
-            if (family === 'task-orchestration' && isCanonicalCodexPrepare(commandArgs)) {
-                const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-                const proof = contextPath
-                    ? controllerProofFromContext(verifyCodexSandboxControllerContextWithWarnings(contextPath).context)
-                    : null;
-                const authority = lifecycleAuthoritySelector(commandArgs);
-                response = requestSandboxTaskControl({
-                    family,
-                    args: commandArgs,
-                    controllerProof: authority ? null : proof,
-                    ...(authority ? { authority } : {})
-                });
-            }
-            else {
-                response = requestSandboxControl({ family, args: commandArgs });
-            }
+            response = requestSandboxControl({ family, args: commandArgs });
         }
         catch (error) {
             if (!(error instanceof SandboxControlClientError))

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

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

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

@@ -2,7 +2,7 @@ import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTa
 import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --stage <stage> --round <round> --artifact <artifact> --reason <reason>\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);

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

@@ -50,6 +50,7 @@ function internalTaskRoutes() {
         descriptor('internal', 'platform-comment', 'recover', 'non-task', 'recovery', 'none'),
         descriptor('internal', 'platform-comment', 'owner', 'task-bound', 'diagnostic'),
         descriptor('internal', 'platform-comment', 'backfill', 'task-bound', 'remote-write'),
+        descriptor('internal', 'platform-comment', 'stage-summary', 'task-bound', 'artifact-write'),
         descriptor('internal', 'platform-comment', 'sync', 'task-bound', 'remote-write'),
         descriptor('internal', 'platform-issue', 'inspect', 'task-bound', 'diagnostic'),
         descriptor('internal', 'platform-issue', 'create', 'task-bound', 'remote-write'),
@@ -228,6 +229,8 @@ 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));
 }
 const TASK_MARKER_KEYS = [
@@ -351,14 +354,16 @@ export function resolveSandboxControlTransport(env = process.env, options = {})
         if (!hasCompleteConfig) {
             return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
         }
-        return { kind: 'broker-client', reasonCode: null };
+        return { kind: options.localWorkflow ? 'sandbox-local' : 'broker-client', reasonCode: null };
     }
     if (!hasAnyMarker)
         return { kind: 'direct-host', reasonCode: null };
     if (!hasCompleteConfig || (taskBound && !runtime) || (!taskBound && runtime)) {
         return { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_CONFIGURATION_INCOMPLETE' };
     }
-    return { kind: 'broker-client', reasonCode: null };
+    return options.localWorkflow
+        ? { kind: 'fail-closed', reasonCode: 'SANDBOX_CONTROL_IDENTITY_MISSING' }
+        : { kind: 'broker-client', reasonCode: null };
 }
 export function hasTaskBoundMarker(env = process.env) {
     return taskMarkerState(env) === 'task-bound';

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

@@ -4,7 +4,7 @@ import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.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> [--recovery-id <id>] [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -30,7 +30,7 @@ async function taskReview(args = []) {
         failUsage(error instanceof Error ? error.message : String(error));
         return;
     }
-    const { stage, artifact, recoveryId, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+    const { stage, artifact, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
     const operation = args[1];
     const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
     if (dryRunConflict) {
@@ -47,8 +47,8 @@ async function taskReview(args = []) {
     try {
         result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-review.${operation}`, async () => {
             let current = operation === 'preflight'
-                ? preflightReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true })
-                : finalizeReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true });
+                ? preflightReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true })
+                : finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
             if (operation === 'preflight')
                 return current;
             if (current.status !== 'failed' || !overrideTicket)
@@ -63,7 +63,7 @@ async function taskReview(args = []) {
                 target: overrideTarget, scope: overrideScope
             }, {
                 effectExecutor: (capability) => {
-                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, recoveryId, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
+                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true, manualOverride: capability });
                     current = retried;
                     return retried.status === 'failed' || retried.status === 'planned'
                         ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no review effect was committed' : `${retried.error?.code ?? 'REVIEW_FAILED'}: ${retried.error?.message ?? 'manual review effect failed'}` }

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

@@ -135,12 +135,6 @@ function snapshotValidation(repoRoot, commit, options) {
                 cleanupError = error;
             }
         }
-        try {
-            git(repoRoot, ['worktree', 'prune']);
-        }
-        catch (error) {
-            cleanupError ??= error;
-        }
         try {
             fs.rmSync(tempRoot, { recursive: true, force: true });
         }

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

@@ -171,6 +171,12 @@ function sanitizeMarkdownDocument(value, options = {}) {
 function canonicalizeCommentBody(value) {
     return sanitizeMarkdownDocument(value, { reservedMarkers: [CONTROL_MARKER_PATTERN] });
 }
+function canonicalizeSummaryBody(value) {
+    const sanitized = canonicalizeCommentBody(value);
+    return sanitized.ok
+        ? ok(`${sanitized.value.replace(/\n+$/, '')}\n`)
+        : sanitized;
+}
 function renderSafeCodeFence(value, language = '', reservedMarkers = [CONTROL_MARKER_PATTERN]) {
     const content = markerSafe(normalized(value), reservedMarkers);
     const longestRun = Math.max(0, ...(content.match(/`+/g) || []).map((run) => run.length));
@@ -225,5 +231,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, sanitizeMarkdownDocument, splitDocumentPlaceholder };
+export { CONTROL_MARKER_PATTERN, escapeHtmlAttribute, escapeHtmlText, escapeMarkdownLiteral, fenceRanges, renderSafeCodeFence, canonicalizeCommentBody, canonicalizeSummaryBody, sanitizeMarkdownDocument, splitDocumentPlaceholder };
 //# sourceMappingURL=comment-safety.js.map

package/dist/lib/platform/github-provider.js

@@ -278,13 +278,14 @@ function issueSnapshot(value, graph) {
         displayUrl: value.url
     };
 }
-function commentSnapshot(value) {
+function commentSnapshot(value, createdSequence = null) {
     return {
         id: String(value.id),
         author: value.user?.login ? { id: String(value.user.login), name: String(value.user.login) } : null,
         body: String(value.body || ''),
         createdAt: String(value.created_at || ''),
-        updatedAt: String(value.updated_at || value.created_at || '')
+        updatedAt: String(value.updated_at || value.created_at || ''),
+        createdSequence
     };
 }
 function createReceipt(remoteId) {
@@ -555,7 +556,16 @@ function createGitHubOperations(client) {
             if (!response.ok)
                 return response;
             const values = Array.isArray(response.value) ? response.value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]) : [];
-            return { ok: true, value: values.filter((entry) => entry && entry.id !== undefined).map(commentSnapshot) };
+            const comments = values.filter((entry) => entry && typeof entry === 'object');
+            let previous = 0;
+            const ordered = comments.length === values.length && comments.every((entry) => {
+                const id = Number(entry.id);
+                if (!Number.isSafeInteger(id) || id <= previous)
+                    return false;
+                previous = id;
+                return true;
+            });
+            return { ok: true, value: comments.map((comment) => commentSnapshot(comment, ordered ? Number(comment.id) : null)) };
         },
         async write({ context, parent, body, existingComment }) {
             const number = resourceIdentityNumber(parent);

package/dist/lib/platform/issue-comments.js

@@ -29,8 +29,6 @@ const ARTIFACT_TITLES = {
     'review-plan': '技术方案审查',
     code: '实现报告',
     'review-code': '代码审查',
-    'manual-validation': '人工验证报告',
-    'validation-run': '验证运行证据',
     'pr-review': 'PR 审查报告'
 };
 function normalizeCommentContent(content) {
@@ -100,7 +98,7 @@ function taskCommentLanguage(repoRoot) {
 }
 function artifactIdentity(artifact) {
     const stem = path.basename(artifact, '.md');
-    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r(\d+))?$/);
+    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|pr-review)(?:-r(\d+))?$/);
     if (!match)
         throw new Error(`unsupported artifact '${artifact}'`);
     const base = ARTIFACT_TITLES[match[1]];
@@ -373,6 +371,38 @@ function relatedComments(comments, prefix) {
         return first === base || (first.startsWith(chunkNamespace) && first.endsWith(' -->'));
     });
 }
+function taskManagedComment(comment, taskId) {
+    const marker = normalizeCommentContent(comment.body).split('\n', 1)[0] || '';
+    return marker === MARKERS.task(taskId)
+        || marker === MARKERS.summary(taskId)
+        || marker.startsWith(`<!-- sync-issue:${taskId}:`);
+}
+function summaryPosition(comments, taskId) {
+    const managed = comments.filter((comment) => taskManagedComment(comment, taskId));
+    const summary = managed.filter((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] === MARKERS.summary(taskId));
+    if (summary.length !== 1)
+        return { ok: false, known: false, summary: null };
+    if (managed.some((comment) => !Number.isSafeInteger(comment.createdSequence) || Number(comment.createdSequence) < 1)) {
+        return { ok: false, known: false, summary: summary[0] };
+    }
+    const sequence = summary[0].createdSequence;
+    return { ok: managed.every((comment) => sequence >= comment.createdSequence), known: true, summary: summary[0] };
+}
+async function listedComments(provider, loaded, parent) {
+    return provider.comments?.list
+        ? provider.comments.list({ context: providerOperationContext(loaded), parent }).then((response) => response.ok
+            ? {
+                ok: true,
+                value: response.value.map((comment) => ({
+                    id: providerCommentId(comment.id, provider),
+                    body: comment.body,
+                    user: comment.author?.name ? { login: comment.author.name } : undefined,
+                    createdSequence: comment.createdSequence
+                }))
+            }
+            : response)
+        : unsupportedProviderOperation(provider, 'comments.list');
+}
 function validateRelatedMarkerSet(comments, prefix) {
     const markers = comments.map((comment) => normalizeCommentContent(comment.body).split('\n', 1)[0] || '');
     if (new Set(markers).size !== markers.length)
@@ -442,18 +472,7 @@ async function syncPlatformComment(taskRef, options) {
     if (!hasResolvedPlatformContext(context) || !loaded.ok)
         return context;
     const issue = resourceIdentityNumber(issueIdentityFromTask);
-    const listed = loaded.value.provider.comments?.list
-        ? await loaded.value.provider.comments.list({
-            context: providerOperationContext(loaded.value),
-            parent: issueIdentityFromTask
-        }).then((response) => response.ok
-            ? { ok: true, value: response.value.map((comment) => ({
-                    id: providerCommentId(comment.id, loaded.value.provider),
-                    body: comment.body,
-                    user: comment.author?.name ? { login: comment.author.name } : undefined
-                })) }
-            : response)
-        : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
+    const listed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
     if (!listed.ok) {
         return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
             ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
@@ -555,6 +574,65 @@ async function syncPlatformComment(taskRef, options) {
         }
         operations.push({ name: `comment:${comment.id}`, status: 'applied', reasonCode: 'STALE_CHUNK_DELETED' });
     }
+    if (options.kind === 'summary') {
+        const refreshed = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
+        if (!refreshed.ok) {
+            return platformResult(refreshed.error.retryable ? 'blocked' : 'failed', {
+                ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: refreshed.error
+            });
+        }
+        const position = summaryPosition(refreshed.value, resolved.taskId);
+        if (!position.ok && !position.known) {
+            return platformResult('blocked', {
+                ...contextFields(context), resource: { kind: 'issue', number: issue }, operations,
+                error: { code: 'SUMMARY_POSITION_UNVERIFIED', message: 'Summary comment ordering cannot be proven from the provider snapshot', retryable: true }
+            });
+        }
+        if (!position.ok && position.summary) {
+            const owner = position.summary.user?.login;
+            if (!options.summaryAuthorization || options.summaryAuthorization.sha256 !== createHash('sha256').update(options.body ?? '').digest('hex')
+                || !owner || owner !== context.platform.currentUser) {
+                return platformResult('failed', {
+                    ...contextFields(context), resource: { kind: 'issue', number: issue }, operations,
+                    error: { code: 'SUMMARY_REPOSITION_UNAUTHORIZED', message: 'summary reposition requires current finalization authorization and an owned durable summary', retryable: false }
+                });
+            }
+            const deleted = loaded.value.provider.comments?.delete
+                ? await loaded.value.provider.comments.delete({
+                    context: providerOperationContext(loaded.value), parent: issueIdentityFromTask,
+                    comment: { kind: 'id', value: String(position.summary.id) },
+                    mutation: { idempotencyKey: `summary-reposition-delete:${resolved.taskId}:${position.summary.id}` }
+                })
+                : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
+            if (!deleted.ok) {
+                return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
+                    ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: deleted.error
+                });
+            }
+            const written = loaded.value.provider.comments?.write
+                ? await loaded.value.provider.comments.write({
+                    context: providerOperationContext(loaded.value), parent: issueIdentityFromTask, body: desired[0].body,
+                    mutation: { idempotencyKey: `summary-reposition-write:${resolved.taskId}` }
+                })
+                : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
+            if (!written.ok) {
+                return platformResult(written.error.retryable ? 'blocked' : 'failed', {
+                    ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error: written.error
+                });
+            }
+            ids.splice(0, ids.length, providerCommentId(written.value.remoteId, loaded.value.provider));
+            operations.push({ name: `comment:${desired[0].marker}`, status: 'applied', reasonCode: 'SUMMARY_REPOSITIONED' });
+            const reconciled = await listedComments(loaded.value.provider, loaded.value, issueIdentityFromTask);
+            if (!reconciled.ok || !summaryPosition(reconciled.value, resolved.taskId).ok) {
+                const error = reconciled.ok
+                    ? { code: 'SUMMARY_POSITION_UNVERIFIED', message: 'Summary comment is not provably last among task-managed comments', retryable: true }
+                    : reconciled.error;
+                return platformResult(error.retryable ? 'blocked' : 'failed', {
+                    ...contextFields(context), resource: { kind: 'issue', number: issue }, operations, error
+                });
+            }
+        }
+    }
     const changed = operations.some((operation) => operation.status === 'applied');
     const result = platformResult(changed ? 'applied' : 'no-op', {
         ...contextFields(context),

package/dist/lib/platform/pr-summary.js

@@ -13,7 +13,7 @@ import { platformResult } from './types.js';
 import { providerError, providerOperationContext, providerStatus, providerResourceToken, resourceIdentityNumber, unsupportedProviderOperation } from './provider-bridge.js';
 import { resourceIdentityEquals } from './resource-identity.js';
 import { buildPrChangeReport, CANONICAL_REPORT_PLACEHOLDER, readPrChangeReport, replaceCanonicalReportPlaceholder, runMechanicalChangeReport, taskIntentDigest, validateMechanicalReport, validatePrecheckCandidate, writePrChangeReportAtomic } from './pr-change-report.js';
-import { manualValidationFinalSummaryProjectionMatches } from '../task/manual-validation-receipt.js';
+import { MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, manualValidationFinalSummaryProjectionMatches } from '../task/manual-validation-receipt.js';
 import { readManualValidationCompletion } from '../task/manual-validation-completion.js';
 function summaryMarker(taskId) {
     return `<!-- sync-pr:${taskId}:summary -->`;
@@ -515,6 +515,7 @@ async function syncPullRequestSummary(taskRef, options) {
             if (!initial.ok)
                 return fail(initial.status, context, initial.error);
             const manual = options.manualValidation;
+            let manualEvidenceDigest = null;
             const hasFinalManualValidation = /###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)/u.test(options.body);
             if (hasFinalManualValidation && (!manual || manual.phase !== 'final'))
                 return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_REQUIRED', message: 'final manual-validation summary requires the transaction coordinator', retryable: false }, prNumber);
@@ -538,6 +539,7 @@ async function syncPullRequestSummary(taskRef, options) {
                     if (!completion.ok)
                         return fail('failed', context, platformError(completion.error), prNumber);
                     const { receipt, transaction } = completion.value;
+                    manualEvidenceDigest = receipt.evidenceDigest;
                     if (transaction.phase !== 'final-promotion-in-progress' || !transaction.eventAppended)
                         return fail('failed', context, { code: 'MANUAL_VALIDATION_TRANSACTION_PHASE_INVALID', message: 'final summary requires a receipt-backed promotion intent', retryable: false }, prNumber);
                     if (!manualValidationFinalSummaryProjectionMatches(options.body, receipt))
@@ -581,7 +583,10 @@ async function syncPullRequestSummary(taskRef, options) {
             const replaced = replaceCanonicalReportPlaceholder(`${prefix.value}${placeholder}${suffix.value}`, report.value);
             if (!replaced.ok)
                 return fail('failed', context, platformError(replaced.error));
-            const desired = buildPullRequestSummary(resolved.taskId, replaced.value, initial.value.head.sha, renderHumanOverrideAudit(taskContent));
+            const renderedBody = manual?.phase === 'final'
+                ? replaced.value.replace(MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, `<!-- manual-validation-receipt: transaction=${manual.transactionId}; receipt=${manual.receiptDigest}; evidence=${manualEvidenceDigest}; head=${manual.prHeadSha} -->`)
+                : replaced.value;
+            const desired = buildPullRequestSummary(resolved.taskId, renderedBody, initial.value.head.sha, renderHumanOverrideAudit(taskContent));
             if (!isSafeSummaryEnvelope(desired, resolved.taskId))
                 return fail('failed', context, {
                     code: 'PR_SUMMARY_RENDER_INVALID',

package/dist/lib/platform/provider-contract.d.ts

@@ -87,6 +87,8 @@ type RemoteCommentSnapshot = {
     body: string;
     createdAt: string;
     updatedAt: string;
+    /** Strict creation order when the provider can prove it for this list snapshot. */
+    createdSequence: number | null;
 };
 type ChangeRequestSnapshot = {
     id: string;

package/dist/lib/platform/provider-validation.js

@@ -189,13 +189,18 @@ function issueType(value, label) {
 }
 function validateComment(value) {
     const item = record(value, 'comment');
-    exactKeys(item, ['id', 'author', 'body', 'createdAt', 'updatedAt'], 'comment');
+    exactKeys(item, ['id', 'author', 'body', 'createdAt', 'updatedAt', 'createdSequence'], 'comment');
     return {
         id: stringValue(item.id, 'comment.id'),
         author: author(item.author, 'comment.author'),
         body: stringValue(item.body, 'comment.body', true),
         createdAt: utcTimestamp(item.createdAt, 'comment.createdAt'),
-        updatedAt: utcTimestamp(item.updatedAt, 'comment.updatedAt')
+        updatedAt: utcTimestamp(item.updatedAt, 'comment.updatedAt'),
+        createdSequence: item.createdSequence === null ? null : (() => {
+            if (!Number.isSafeInteger(item.createdSequence) || Number(item.createdSequence) < 1)
+                throw new Error('comment.createdSequence must be a positive safe integer or null');
+            return Number(item.createdSequence);
+        })()
     };
 }
 function validateChangeRequest(value, expectedKind, requireIdentity = false) {

package/dist/lib/platform/verification-sync.js

@@ -11,7 +11,7 @@ import { planInLabelUpdate, validateInLabelMapping } from "./in-label-sync.js";
 import { readPrDeliveryFact } from "../task/pr-delivery-fact.js";
 import { providerError, providerOperationContext, resourceIdentityNumber, unsupportedProviderOperation } from "./provider-bridge.js";
 import { taskIssueIdentity } from "./task-identities.js";
-import { renderTaskCommentResult } from "./issue-comments.js";
+import { MARKERS, renderTaskCommentResult } from "./issue-comments.js";
 import { CONTROL_MARKER_PATTERN, canonicalizeCommentBody, renderSafeCodeFence, sanitizeMarkdownDocument } from "./comment-safety.js";
 const CHECK_TYPE = "platform-sync";
 const VERSION_LINE_REGEX = /^[0-9]+\.[0-9]+\.x$/;
@@ -258,7 +258,9 @@ async function fetchRemoteData(context, shared) {
     }
     return {
         issue,
-        comments: facts.value.comments.map((comment) => ({ id: comment.id, body: comment.body })),
+        comments: facts.value.comments.map((comment) => ({
+            id: comment.id, body: comment.body, createdSequence: comment.createdSequence
+        })),
         prComments,
         prLabels: changeRequest?.labels || null,
         issueType: issueSnapshot
@@ -320,6 +322,21 @@ function checkCommentMarker(context, remoteData, shared) {
     }
     const comment = findCommentByMarker(remoteData.comments, context.marker);
     if (comment) {
+        if (context.marker === MARKERS.summary(context.task.metadata.id)) {
+            const managed = remoteData.comments.filter((candidate) => {
+                const first = String(candidate.body || '').replace(/\r\n/g, '\n').split('\n', 1)[0] || '';
+                return first === MARKERS.task(context.task.metadata.id)
+                    || first === MARKERS.summary(context.task.metadata.id)
+                    || first.startsWith(`<!-- sync-issue:${context.task.metadata.id}:`);
+            });
+            if (managed.some((candidate) => !Number.isSafeInteger(candidate.createdSequence) || candidate.createdSequence < 1)) {
+                return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} summary comment ordering is not provable`, "check_failed");
+            }
+            const summarySequence = comment.createdSequence;
+            if (!managed.every((candidate) => summarySequence >= candidate.createdSequence)) {
+                return shared.failResult(CHECK_TYPE, `Issue #${context.issueNumber} summary comment is not last among task-managed comments`, "check_failed");
+            }
+        }
         return shared.passResult(CHECK_TYPE, `Issue #${context.issueNumber} has expected comment marker`);
     }
     return shared.failResult(CHECK_TYPE, `Expected comment marker '${context.marker}' not found on Issue #${context.issueNumber}`, "check_failed");