@fitlab-ai/agent-infra 0.11.2 → 0.11.3

package/dist/lib/task/control-recovery.js

@@ -1,7 +1,4 @@
 import { createHash } from 'node:crypto';
-import { isCompletionEvidence } from './orchestration.js';
-import { TASK_WORKFLOW_OPERATIONS } from './workflow-command.js';
-import { sameRecoveryWarning } from './recovery-warning.js';
 /** Normalize the command result once at the control transport boundary. */
 export function parseControlOutput(output) {
     if (output === null)
@@ -20,20 +17,10 @@ export const SANDBOX_CONTROL_REQUIRED_COMPLETION_PHASES = Object.freeze([
     'completed', 'evidence-written', 'publish-authorized'
 ]);
 const LIFECYCLE_INTENTS = ['block', 'activate', 'cancel', 'complete', 'close-codescan', 'close-dependabot', 'restore', 'recover-started'];
-const ORCHESTRATION_INTENTS = [
-    'begin-or-resume', 'route.read', 'route.clean-completion', 'status', 'prepare', 'dispatch',
-    'await-activation', 'recover-prepared', 'hook-start', 'hook-stop', 'advance', 'pause'
-];
 export const SANDBOX_CONTROL_RECOVERY_OPERATIONS = Object.freeze([
     ...LIFECYCLE_INTENTS.map((intent) => ({ family: 'task-lifecycle', intent, class: 'lifecycle-mutation' })),
     { family: 'task-finalization', intent: 'complete', class: 'finalization' },
-    ...ORCHESTRATION_INTENTS.map((intent) => ({
-        family: 'task-orchestration',
-        intent,
-        class: intent === 'route.clean-completion' ? 'route.clean-completion' : intent === 'route.read' || intent === 'status' ? 'read-only' : 'orchestration'
-    })),
     { family: 'task-create', intent: 'create', class: 'task-create' },
-    ...TASK_WORKFLOW_OPERATIONS.map((intent) => ({ family: 'task-workflow', intent, class: intent === 'artifact-inspect' || intent === 'decision-next-id' ? 'read-only' : 'workflow' })),
     ...['open', 'close', 'verify'].map((intent) => ({ family: 'codex-controller', intent, class: 'codex-controller' }))
 ]);
 export function digestControlRecoveryIntent(family, intent) {
@@ -53,30 +40,8 @@ function domainEvidenceMatches(operation, result, domain) {
         return false;
     if (domain.consistent !== true)
         return false;
-    if (operation.class === 'route.clean-completion') {
-        const completion = domain.completionEvidence;
-        const snapshot = domain.snapshot;
-        const lastReviewedCommit = domain.lastReviewedCommit;
-        return result.status === 'completed'
-            && domain.status === 'completed'
-            && domain.pendingDelegation === null
-            && isCompletionEvidence(completion)
-            && snapshot?.head === completion.head
-            && snapshot.headTree === completion.headTree
-            && snapshot.worktreeTree === completion.worktreeTree
-            && lastReviewedCommit === completion.lastReviewedCommit;
-    }
-    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started') {
-        const retryRequired = domain.recoveryState === 'retry-required'
-            && sameRecoveryWarning(domain.warning, result.warning);
-        return result.targetState === 'active'
-            && ['applied', 'no-op'].includes(String(result.status))
-            && domain.recovery === true
-            && domain.targetState === 'active'
-            && (domain.recoveryState === 'released' || retryRequired);
-    }
-    if (operation.class === 'read-only')
-        return result.changed === false && domain.snapshotValid === true;
+    if (operation.family === 'task-lifecycle' && operation.intent === 'recover-started')
+        return false;
     return true;
 }
 export function classifySandboxControlRecovery(input) {
@@ -127,11 +92,7 @@ export function classifySandboxControlRecovery(input) {
     return {
         outcome: 'success',
         responseReconstructable: true,
-        reasonCode: input.operation.class === 'route.clean-completion' && result.changed === false
-            ? 'RECOVERY_ROUTE_COMPLETION_NOOP'
-            : input.operation.intent === 'recover-started' && input.domain?.recoveryState === 'retry-required'
-                ? 'RECOVERY_RELEASE_RETRY_REQUIRED'
-                : 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
+        reasonCode: 'RECOVERY_TERMINAL_AND_DOMAIN_MATCH'
     };
 }
 export function operationRecoveryBinding(requestId, generation, taskId, family, intent) {

package/dist/lib/task/delegation-receipts.js

@@ -149,7 +149,7 @@ function hasStatusBoundEvidence(receipt) {
             && host !== undefined
             && Number.isSafeInteger(host.stopRevision)
             && host.stopRevision > host.startRevision
-            && host.consumer === `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+            && host.consumer === receipt.id
             && exactText(host.consumedAt);
     }
     if (!exactText(receipt.agent)
@@ -405,7 +405,7 @@ function abortActivatedDelegation(receipt, event) {
     if (event.childId !== receipt.childId
         || !Number.isSafeInteger(event.stopRevision)
         || event.stopRevision <= receipt.hostEvidence.startRevision
-        || event.consumer !== `lifecycle-recovery:${receipt.taskId}:${receipt.id}`
+        || event.consumer !== receipt.id
         || !exactText(event.consumedAt)) {
         return fail('DELEGATION_RECOVERY_EVIDENCE_INVALID', 'recovery stop evidence does not match the activated delegation');
     }

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

@@ -5,9 +5,7 @@ const COMPLETION_BACKFILL_FAMILIES = [
     'plan',
     'review-plan',
     'code',
-    'review-code',
-    'manual-validation',
-    'validation-run'
+    'review-code'
 ];
 function inspectCompletionArtifacts(taskRef, options = {}) {
     const artifacts = [];

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

@@ -1,7 +1,7 @@
 export function taskFinalizationReceiptState(receipt) {
     if (receipt.lifecycle !== 'done' || receipt.taskComment === 'pending'
         || receipt.verification === 'pending' || receipt.summary === 'pending'
-        || receipt.postSummaryVerification === 'pending' || receipt.warningProjection !== 'done')
+        || receipt.warningProjection !== 'done')
         return 'pending';
     if (receipt.lastError !== null || receipt.warnings.some((warning) => warning.status === 'open'))
         return 'unresolved';

package/dist/lib/task/finalization.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { syncPlatformComment } from '../platform/issue-comments.js';
 import { canonicalizeSummaryBody } from '../platform/comment-safety.js';
+import { backfillCompletionComments } from '../platform/completion-backfill.js';
 import { taskIssueIdentity } from '../platform/task-identities.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { applyTaskLifecycle } from './lifecycle.js';
@@ -12,8 +13,8 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import { verifyTaskEvent } from './verification.js';
 import { projectFinalizationWarning } from './workflow-warning-intents.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-const RECEIPT_VERSION = 3;
-const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary', 'post-summary-verification'];
+const RECEIPT_VERSION = 4;
+const FINALIZATION_STEPS = ['lifecycle', 'task-comment', 'verification', 'summary'];
 function finalizationRoot(repoRoot) {
     return path.join(repoRoot, '.agents', 'workspace', '.task-finalization');
 }
@@ -34,11 +35,11 @@ function failed(taskId, error, overrides = {}) {
         status: error.retryable ? 'blocked' : 'failed',
         changed: false,
         taskId,
+        backfill: null,
         lifecycle: null,
         taskComment: null,
         verification: null,
         summary: null,
-        postSummaryVerification: null,
         completedSteps: [],
         pendingSteps: [...FINALIZATION_STEPS],
         result: error.retryable ? 'blocked' : 'failed',
@@ -58,10 +59,8 @@ function emptyReceipt(taskId, controlBinding) {
         taskComment: 'pending',
         verification: 'pending',
         summary: 'pending',
-        postSummaryVerification: 'pending',
         warningProjection: 'done',
         warnings: [],
-        summarySha256: null,
         ...(controlBinding ? { controlBinding } : {}),
         updatedAt: now(),
         lastError: null
@@ -97,10 +96,8 @@ function validateReceipt(value, taskId) {
         || !states.includes(String(receipt.taskComment))
         || !states.includes(String(receipt.verification))
         || !states.includes(String(receipt.summary))
-        || !states.includes(String(receipt.postSummaryVerification))
         || !['pending', 'done'].includes(String(receipt.warningProjection))
         || !Array.isArray(receipt.warnings) || receipt.warnings.some((warning) => !validWarning(warning))
-        || (receipt.summarySha256 !== null && (typeof receipt.summarySha256 !== 'string' || !/^[a-f0-9]{64}$/u.test(receipt.summarySha256)))
         || typeof receipt.updatedAt !== 'string'
         || (receipt.lastError !== null && (typeof receipt.lastError !== 'object' || Array.isArray(receipt.lastError)))
         || (receipt.controlBinding !== undefined && (!controlBinding || typeof controlBinding !== 'object'
@@ -154,8 +151,6 @@ function pendingSteps(receipt) {
 function stepState(receipt, step) {
     if (step === 'task-comment')
         return receipt.taskComment;
-    if (step === 'post-summary-verification')
-        return receipt.postSummaryVerification;
     return receipt[step];
 }
 function lifecycleStep(result) {
@@ -436,16 +431,13 @@ function readDeliverySummary(taskDir, taskId) {
 }
 async function syncPendingSummary(input) {
     let { receipt } = input;
-    if (receipt.summary !== 'pending') {
-        return { receipt, step: { status: receipt.summary === 'skipped' ? 'skipped' : 'no-op', changed: false, error: null }, changed: false, error: null };
-    }
     try {
         const resolved = resolveTaskRef(input.taskId, { repoRoot: input.repoRoot });
         if (!resolved.ok || resolved.state !== 'completed')
             throw Object.assign(new Error('completed task is unavailable for summary sync'), { code: 'SUMMARY_STAGING_INVALID' });
         if (!taskIssueIdentity(parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8')))) {
             receipt = updateReceipt(input.repoRoot, receipt, {
-                summary: 'skipped', postSummaryVerification: 'skipped', summarySha256: null, lastError: null
+                summary: 'skipped', lastError: null
             });
             return { receipt, step: { status: 'skipped', changed: false, error: null }, changed: false, error: null };
         }
@@ -460,8 +452,7 @@ async function syncPendingSummary(input) {
             const resolvedWarning = receipt.warnings.some((warning) => warning.step === 'summary' && warning.status === 'open');
             const warnings = resolveStepWarnings(receipt, 'summary');
             receipt = updateReceipt(input.repoRoot, receipt, {
-                summary: skipped ? 'skipped' : 'done', postSummaryVerification: skipped ? 'skipped' : receipt.postSummaryVerification,
-                summarySha256: skipped ? null : summary.sha256,
+                summary: skipped ? 'skipped' : 'done',
                 taskComment: resolvedWarning ? 'pending' : receipt.taskComment,
                 warningProjection: warnings.some((warning) => warning.status === 'open') ? 'pending' : 'done',
                 warnings,
@@ -488,14 +479,9 @@ async function syncPendingSummary(input) {
         return { receipt, step: { status: 'blocked', changed: false, error }, changed: false, error };
     }
 }
-function clearDeliverySummary(taskDir) {
-    const file = path.join(taskDir, '.delivery-summary.json');
-    if (fs.existsSync(file))
-        fs.unlinkSync(file);
-}
 function terminalResult(taskId, receipt, steps, changed, error = null) {
     const pending = pendingSteps(receipt);
-    const blocked = [steps.lifecycle, steps.taskComment, steps.verification, steps.summary, steps.postSummaryVerification].some((step) => step?.status === 'blocked');
+    const blocked = [steps.backfill, steps.lifecycle, steps.taskComment, steps.verification, steps.summary].some((step) => step?.status === 'blocked');
     const warnings = openWarnings(receipt);
     const postLifecyclePending = receipt.lifecycle === 'done' && (pending.some((step) => step !== 'lifecycle') || receipt.warningProjection === 'pending');
     const hardError = error?.code.startsWith('FINALIZATION_') || error?.code === 'TASK_FINALIZATION_RECEIPT_INVALID';
@@ -503,18 +489,18 @@ function terminalResult(taskId, receipt, steps, changed, error = null) {
         status: hardError ? (error?.retryable ? 'blocked' : 'failed') : pending.length === 0 ? 'completed' : postLifecyclePending ? 'completed' : blocked ? 'blocked' : 'failed',
         changed,
         taskId,
+        backfill: steps.backfill ?? null,
         lifecycle: steps.lifecycle ?? null,
         taskComment: steps.taskComment ?? null,
         verification: steps.verification ?? null,
         summary: steps.summary ?? null,
-        postSummaryVerification: steps.postSummaryVerification ?? null,
         completedSteps: completedSteps(receipt),
         pendingSteps: pending,
         result: hardError
             ? (error?.retryable ? 'blocked' : 'failed')
-            : postLifecyclePending && (warnings.length > 0 || receipt.warningProjection === 'pending')
+            : postLifecyclePending
                 ? 'completed_with_warnings'
-                : pending.length === 0 || postLifecyclePending
+                : pending.length === 0
                     ? 'completed'
                     : blocked
                         ? 'blocked'
@@ -526,6 +512,7 @@ function terminalResult(taskId, receipt, steps, changed, error = null) {
 async function applyUnderLock(request, taskId, options) {
     const repoRoot = path.resolve(options.repoRoot);
     const lifecycle = options.lifecycle ?? applyTaskLifecycle;
+    const backfill = options.backfill ?? backfillCompletionComments;
     const commentSync = options.commentSync ?? syncPlatformComment;
     const verify = options.verify ?? verifyTaskEvent;
     const consumedCapabilities = new Set();
@@ -562,8 +549,36 @@ async function applyUnderLock(request, taskId, options) {
             return failed(taskId, errorOf(error, 'TASK_FINALIZATION_PREFLIGHT_FAILED', true));
         }
     }
-    let lifecycleResult = null;
     let changed = false;
+    let backfillResult = null;
+    try {
+        const result = await backfill(taskId, { agent: request.agent, cwd: repoRoot });
+        backfillResult = commentStep(result);
+        const issueNotLinked = result.status === 'no-op' && result.error?.code === 'ISSUE_NOT_LINKED';
+        if (!issueNotLinked && (result.status !== 'applied' && result.status !== 'no-op' || result.error)) {
+            const detail = backfillResult.error ?? {
+                code: 'COMPLETION_BACKFILL_FAILED', message: 'completion artifact backfill did not reach a successful terminal result', retryable: true
+            };
+            return failed(taskId, detail, {
+                backfill: backfillResult,
+                completedSteps: completedSteps(receipt),
+                pendingSteps: pendingSteps(receipt)
+            });
+        }
+        changed = result.changed;
+        if (result.changed && receipt.taskComment !== 'pending') {
+            receipt = updateReceipt(repoRoot, receipt, { taskComment: 'pending' });
+        }
+    }
+    catch (error) {
+        const detail = errorOf(error, 'COMPLETION_BACKFILL_FAILED', true);
+        return failed(taskId, detail, {
+            backfill: { status: detail.retryable ? 'blocked' : 'failed', changed: false, error: detail },
+            completedSteps: completedSteps(receipt),
+            pendingSteps: pendingSteps(receipt)
+        });
+    }
+    let lifecycleResult = null;
     try {
         const resolved = resolveTaskRef(taskId, { repoRoot });
         const registry = resolved.ok && resolved.state === 'completed' ? inspectShortIdRegistry(repoRoot) : null;
@@ -575,6 +590,7 @@ async function applyUnderLock(request, taskId, options) {
             };
             receipt = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: detail });
             return terminalResult(taskId, receipt, {
+                backfill: backfillResult,
                 lifecycle: { status: 'failed', changed: false, error: detail },
                 taskComment: null,
                 verification: null
@@ -589,6 +605,7 @@ async function applyUnderLock(request, taskId, options) {
             };
             receipt = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: detail });
             return terminalResult(taskId, receipt, {
+                backfill: backfillResult,
                 lifecycle: { status: 'failed', changed: false, error: detail },
                 taskComment: null,
                 verification: null
@@ -604,9 +621,9 @@ async function applyUnderLock(request, taskId, options) {
             lifecycleResult = lifecycleStep(result);
             if (result.status !== 'applied' && result.status !== 'no-op') {
                 receipt = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: lifecycleResult.error });
-                return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment: null, verification: null }, result.changed, lifecycleResult.error);
+                return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment: null, verification: null }, result.changed, lifecycleResult.error);
             }
-            changed = result.changed;
+            changed = changed || result.changed;
             receipt = updateReceipt(repoRoot, receipt, { lifecycle: 'done', lastError: null });
         }
     }
@@ -616,7 +633,7 @@ async function applyUnderLock(request, taskId, options) {
             receipt = updateReceipt(repoRoot, receipt, { lifecycle: 'pending', lastError: detail });
         }
         catch { /* preserve the primary error */ }
-        return failed(taskId, detail, { lifecycle: lifecycleResult });
+        return failed(taskId, detail, { backfill: backfillResult, lifecycle: lifecycleResult });
     }
     let taskComment = null;
     receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
@@ -627,7 +644,7 @@ async function applyUnderLock(request, taskId, options) {
     taskComment = initialComment.step;
     changed = changed || initialComment.changed;
     if (initialComment.error) {
-        return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification: null }, changed, initialComment.error);
+        return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification: null }, changed, initialComment.error);
     }
     let verification = null;
     try {
@@ -650,7 +667,7 @@ async function applyUnderLock(request, taskId, options) {
                     taskComment = finalComment.step;
                 changed = changed || finalComment.changed;
                 if (finalComment.error) {
-                    return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification }, changed, finalComment.error);
+                    return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification }, changed, finalComment.error);
                 }
             }
             else {
@@ -678,7 +695,7 @@ async function applyUnderLock(request, taskId, options) {
                     taskComment = warningComment.step;
                 changed = changed || warningComment.changed;
             }
-            return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification }, changed, detail);
+            return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification }, changed, detail);
         }
     }
     catch (error) {
@@ -706,7 +723,7 @@ async function applyUnderLock(request, taskId, options) {
                 retryable: true
             };
             return terminalResult(taskId, receipt, {
-                lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail }
+                backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail }
             }, changed, hardError);
         }
         try {
@@ -717,107 +734,17 @@ async function applyUnderLock(request, taskId, options) {
             changed = changed || warningComment.changed;
         }
         catch { /* preserve the primary error */ }
-        return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail } }, changed, detail);
+        return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification: { status: 'blocked', changed: false, error: detail } }, changed, detail);
     }
-    const summary = await syncPendingSummary({ repoRoot, taskId, agent: request.agent, receipt, commentSync });
+    let summary = await syncPendingSummary({ repoRoot, taskId, agent: request.agent, receipt, commentSync });
     receipt = summary.receipt;
     changed = changed || summary.changed;
     if (summary.error) {
         receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-        const warningComment = await syncPendingTaskComment({
-            repoRoot, taskId, agent: request.agent, receipt, commentSync, consumedCapabilities
-        });
-        receipt = warningComment.receipt;
-        if (warningComment.step.status !== 'no-op')
-            taskComment = warningComment.step;
-        changed = changed || warningComment.changed;
-        return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step }, changed, summary.error);
-    }
-    let postSummaryVerification = null;
-    if (receipt.postSummaryVerification === 'skipped') {
-        postSummaryVerification = { status: 'skipped', changed: false, error: null };
-    }
-    else if (receipt.postSummaryVerification !== 'pending') {
-        const replay = await commentSync(taskId, {
-            kind: 'summary', agent: request.agent, body: '', cwd: repoRoot, verifyOnly: true,
-            summaryAuthorization: { sha256: receipt.summarySha256 ?? '' }
-        });
-        postSummaryVerification = commentStep(replay);
-        if (replay.status !== 'applied' && replay.status !== 'no-op') {
-            const error = postSummaryVerification.error ?? { code: 'SUMMARY_VERIFICATION_FAILED', message: 'summary replay verification failed', retryable: true };
-            const warnings = replaceWarning(receipt, warningFromError('post-summary-verification', error), 'open');
-            receipt = updateReceipt(repoRoot, receipt, { postSummaryVerification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: error });
-            receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-            return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step, postSummaryVerification }, changed, error);
-        }
-    }
-    else {
-        try {
-            const summaryVerification = await commentSync(taskId, {
-                kind: 'summary', agent: request.agent, body: '', cwd: repoRoot, verifyOnly: true,
-                summaryAuthorization: { sha256: receipt.summarySha256 ?? '' }
-            });
-            if (summaryVerification.status !== 'applied' && summaryVerification.status !== 'no-op') {
-                const error = commentStep(summaryVerification).error ?? { code: 'SUMMARY_VERIFICATION_FAILED', message: 'summary verification failed', retryable: true };
-                const warnings = replaceWarning(receipt, warningFromError('post-summary-verification', error), 'open');
-                receipt = updateReceipt(repoRoot, receipt, { postSummaryVerification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: error });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-                const warningComment = await syncPendingTaskComment({ repoRoot, taskId, agent: request.agent, receipt, commentSync, consumedCapabilities });
-                receipt = warningComment.receipt;
-                if (warningComment.step.status !== 'no-op')
-                    taskComment = warningComment.step;
-                changed = changed || warningComment.changed;
-                return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step, postSummaryVerification: commentStep(summaryVerification) }, changed, error);
-            }
-            const result = await verify({ taskRef: taskId, event: 'complete-task.completed' }, { repoRoot });
-            postSummaryVerification = verificationStep(result);
-            if (result.status === 'pass') {
-                const resolvedWarning = receipt.warnings.some((warning) => warning.step === 'post-summary-verification' && warning.status === 'open');
-                const warnings = resolveStepWarnings(receipt, 'post-summary-verification');
-                receipt = updateReceipt(repoRoot, receipt, {
-                    postSummaryVerification: 'done', taskComment: resolvedWarning ? 'pending' : receipt.taskComment,
-                    warningProjection: warnings.some((warning) => warning.status === 'open') ? 'pending' : 'done', warnings, lastError: null
-                });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-                const warningComment = await syncPendingTaskComment({ repoRoot, taskId, agent: request.agent, receipt, commentSync, consumedCapabilities });
-                receipt = warningComment.receipt;
-                if (warningComment.step.status !== 'no-op')
-                    taskComment = warningComment.step;
-                changed = changed || warningComment.changed;
-            }
-            else {
-                const error = postSummaryVerification.error ?? { code: 'VERIFY_FAILED', message: 'post-summary verification failed', retryable: true };
-                const warnings = replaceWarning(receipt, warningFromError('post-summary-verification', error), 'open');
-                receipt = updateReceipt(repoRoot, receipt, { postSummaryVerification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: error });
-                receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-                const warningComment = await syncPendingTaskComment({ repoRoot, taskId, agent: request.agent, receipt, commentSync, consumedCapabilities });
-                receipt = warningComment.receipt;
-                if (warningComment.step.status !== 'no-op')
-                    taskComment = warningComment.step;
-                changed = changed || warningComment.changed;
-                return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step, postSummaryVerification }, changed, error);
-            }
-        }
-        catch (error) {
-            const detail = errorOf(error, 'POST_SUMMARY_VERIFY_FAILED', true);
-            const warnings = replaceWarning(receipt, warningFromError('post-summary-verification', detail), 'open');
-            receipt = updateReceipt(repoRoot, receipt, { postSummaryVerification: 'pending', taskComment: 'pending', warningProjection: 'pending', warnings, lastError: detail });
-            receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-            const warningComment = await syncPendingTaskComment({ repoRoot, taskId, agent: request.agent, receipt, commentSync, consumedCapabilities });
-            receipt = warningComment.receipt;
-            if (warningComment.step.status !== 'no-op')
-                taskComment = warningComment.step;
-            changed = changed || warningComment.changed;
-            return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step, postSummaryVerification: { status: 'blocked', changed: false, error: detail } }, changed, detail);
-        }
+        return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification, summary: summary.step }, changed, summary.error);
     }
     receipt = reconcileWarningProjection(repoRoot, taskId, receipt, consumedCapabilities);
-    if (receipt.summary !== 'pending' && receipt.postSummaryVerification !== 'pending' && receipt.warningProjection === 'done' && openWarnings(receipt).length === 0) {
-        const resolved = resolveTaskRef(taskId, { repoRoot });
-        if (resolved.ok && resolved.state === 'completed')
-            clearDeliverySummary(resolved.taskDir);
-    }
-    return terminalResult(taskId, receipt, { lifecycle: lifecycleResult, taskComment, verification, summary: summary.step, postSummaryVerification }, changed);
+    return terminalResult(taskId, receipt, { backfill: backfillResult, lifecycle: lifecycleResult, taskComment, verification, summary: summary.step }, changed);
 }
 async function applyTaskFinalization(request, options) {
     if (request.intent !== 'complete' || !request.taskRef || !request.agent) {

package/dist/lib/task/lifecycle.js

@@ -151,7 +151,7 @@ function actionAndNote(request, restoredFiles = 0) {
     if (request.intent === 'close-dependabot')
         return { action: 'Close Dependabot', note: `Dependabot alert #${request.alertNumber} dismissed: ${request.reason}` };
     if (request.intent === 'recover-started')
-        return { action: 'Recover Started', note: request.reason };
+        return { action: 'Recover Started', note: 'automatic recovery' };
     return { action: 'Restore Task', note: `Restored ${restoredFiles} files from Issue #${request.issueNumber}` };
 }
 function matchingCompletion(content, request, restoredFiles = 0) {

package/dist/lib/task/manual-validation-receipt.js

@@ -4,6 +4,7 @@ import { createHash } from 'node:crypto';
 import { MANUAL_VALIDATION_ARTIFACT as ARTIFACT, MANUAL_VALIDATION_SHA40 as SHA40, MANUAL_VALIDATION_SHA64 as SHA64, MANUAL_VALIDATION_TASK_ID as TASK_ID, exactKeys, isRecord, validTimestamp, writeJsonAtomic } from './manual-validation-shared.js';
 const MANUAL_VALIDATION_RECEIPT_SCHEMA = 'agent-infra/manual-validation-receipt';
 const MANUAL_VALIDATION_RECEIPT_VERSION = 1;
+const MANUAL_VALIDATION_RECEIPT_PLACEHOLDER = '[[manual-validation-receipt]]';
 function invalid(message) {
     return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_INVALID', message } };
 }
@@ -33,12 +34,16 @@ function manualValidationFinalSummaryDigest(body) {
     const projection = heading
         ? body.slice(heading.index, heading.index + heading[0].length + (nextSection?.index ?? afterHeading.length)).replace(/\s+$/u, '')
         : body;
-    const preimage = projection.replace(/receipt=(?:[a-f0-9]{64}|<receipt>)/gu, 'receipt=<receipt>');
+    const preimage = projection
+        .replace(/\n*<!--\s*canonical-pr-change-report\s*-->\s*/gu, '')
+        .replace(/<!--\s*manual-validation-receipt:\s*[\s\S]*?-->/gu, MANUAL_VALIDATION_RECEIPT_PLACEHOLDER)
+        .replace(/receipt=(?:[a-f0-9]{64}|<receipt>)/gu, 'receipt=<receipt>');
     return createHash('sha256').update(preimage, 'utf8').digest('hex');
 }
 function manualValidationFinalSummaryProjectionMatches(body, receipt) {
     const identity = `transaction=${receipt.transactionId}; receipt=${receipt.receiptDigest}; evidence=${receipt.evidenceDigest}; head=${receipt.prHeadSha}`;
-    return body.includes(identity) && manualValidationFinalSummaryDigest(body) === receipt.finalSummaryDigest;
+    return (body.includes(identity) || body.includes(MANUAL_VALIDATION_RECEIPT_PLACEHOLDER))
+        && manualValidationFinalSummaryDigest(body) === receipt.finalSummaryDigest;
 }
 function validateManualValidationReceipt(value, expected) {
     if (!isRecord(value))
@@ -101,5 +106,5 @@ function readManualValidationReceipt(taskDir, expected) {
     }
     return validateManualValidationReceipt(value, expected);
 }
-export { MANUAL_VALIDATION_RECEIPT_SCHEMA, MANUAL_VALIDATION_RECEIPT_VERSION, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, manualValidationReceiptDigest, manualValidationReceiptPath, readManualValidationReceipt, validateManualValidationReceipt, writeManualValidationReceiptAtomic };
+export { MANUAL_VALIDATION_RECEIPT_SCHEMA, MANUAL_VALIDATION_RECEIPT_VERSION, MANUAL_VALIDATION_RECEIPT_PLACEHOLDER, createManualValidationReceipt, manualValidationFinalSummaryDigest, manualValidationFinalSummaryProjectionMatches, manualValidationReceiptDigest, manualValidationReceiptPath, readManualValidationReceipt, validateManualValidationReceipt, writeManualValidationReceiptAtomic };
 //# sourceMappingURL=manual-validation-receipt.js.map

package/dist/lib/task/orchestration.js

@@ -1075,6 +1075,14 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
         return failed('ORCHESTRATION_PREPARED_RECOVERY_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
 }
+function recoveryReceiptMatches(receipt, taskId, event) {
+    return receipt.taskId === taskId
+        && receipt.stage === event.stage
+        && receipt.round === event.round
+        && receipt.artifact === event.artifact
+        && receipt.childId === event.childId
+        && normalizeAgentToken(event.startedAgent) === normalizeAgentToken(receipt.client);
+}
 function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -1089,12 +1097,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     const receipt = matches.find((candidate) => candidate.id === event.receiptId);
     if (!receipt)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'recovery receipt does not exist', resolved.taskId);
-    if (receipt.taskId !== resolved.taskId
-        || receipt.stage !== event.stage
-        || receipt.round !== event.round
-        || receipt.artifact !== event.artifact
-        || receipt.childId !== event.childId
-        || normalizeAgentToken(event.startedAgent) !== normalizeAgentToken(receipt.client)) {
+    if (!recoveryReceiptMatches(receipt, resolved.taskId, event)) {
         return failed('ORCHESTRATION_PROVENANCE_MISMATCH', 'recovery selector does not match the delegation receipt', resolved.taskId);
     }
     if (receipt.status === 'aborted' && run.pendingDelegation === null) {
@@ -1106,6 +1109,9 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     if (run.receipts.some((candidate) => candidate.id === receipt.id)) {
         return failed('ORCHESTRATION_RECEIPT_DUPLICATE', 'recovery receipt already exists in the completed receipt history', resolved.taskId);
     }
+    if (run.status !== 'running' || run.pause !== null) {
+        return failed('ORCHESTRATION_RECOVERY_UNSAFE', 'activated recovery cannot replace an unrelated orchestration pause', resolved.taskId);
+    }
     const aborted = abortActivatedDelegation(receipt, {
         childId: event.childId,
         stopRevision: event.stopRevision,

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.2",
-  "sourceInputHash": "0a1ffa8b90a0d157f9b2aabea6a43f946d68a622bde337befe71059f63b3812b",
-  "internalExecutableBuildHash": "b6742e1b5d1b997bf7e21e644bfde2bafaa608f7ede7ca308ff61c2cd19da831"
+  "packageVersion": "0.11.3",
+  "sourceInputHash": "99efbc575d475879773bf1676cc2de5ea628b9c193f69a9812a723313ba5ae7f",
+  "internalExecutableBuildHash": "6912a66863d013c476699b88cc1d4154082971164cbae3f98ea79dda39a46e7a"
 }

package/lib/agent-clients/adapter.ts

@@ -7,6 +7,10 @@ import type {
   AgentClientCapabilityMap,
   AgentClientId
 } from './types.ts';
+import type {
+  OrchestrationOptions,
+  OrchestrationResult
+} from '../task/orchestration.ts';
 import {
   SANDBOX_HOOK_PHASES
 } from '../sandbox/tool-types.ts';
@@ -43,6 +47,41 @@ type AgentClientDelegationEvidence = Readonly<{
   actualReasoningEffort: 'host-event' | 'app-server' | 'spawn-ack' | 'unavailable';
 }>;
 
+type AgentClientLifecycleRecoveryRequest = Readonly<{
+  taskRef: string;
+  intent: 'recover-started';
+  agent: string;
+  auto: true;
+}>;
+
+type AgentClientLifecycleRecoveryResult = Readonly<{
+  status: 'applied' | 'no-op' | 'owner-unknown' | 'conflict';
+  changed: boolean;
+  targetState: 'active';
+  requestRef: string;
+  intent: 'recover-started';
+  taskId: string | null;
+  receiptId: string | null;
+  childId: string | null;
+  error: Readonly<{ code: string; message: string }> | null;
+}>;
+
+type AgentClientOrchestrationAdapter = Readonly<{
+  prepareDelegation?: (
+    taskRef: string,
+    input: Readonly<{
+      client: AgentClientId;
+      requestedModel?: string;
+      requestedReasoningEffort?: string;
+    }>,
+    options?: Readonly<{ repoRoot?: string; orchestrationOptions?: OrchestrationOptions }>
+  ) => Promise<OrchestrationResult>;
+  recoverStarted?: (
+    request: AgentClientLifecycleRecoveryRequest,
+    options: Readonly<{ repoRoot: string }>
+  ) => AgentClientLifecycleRecoveryResult | Promise<AgentClientLifecycleRecoveryResult>;
+}>;
+
 type AgentClientSeedCommand = Readonly<{
   templates: Readonly<{
     en: string;
@@ -75,6 +114,7 @@ type AgentClientAdapter = Readonly<{
   capabilities: AgentClientCapabilities;
   modelSelection: AgentClientModelSelectionContext;
   delegationEvidence: AgentClientDelegationEvidence;
+  orchestrationAdapter?: AgentClientOrchestrationAdapter;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -628,6 +668,9 @@ function defineAgentClientAdapter(
     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,
@@ -650,6 +693,9 @@ export type {
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
   AgentClientDelegationEvidence,
+  AgentClientLifecycleRecoveryRequest,
+  AgentClientLifecycleRecoveryResult,
+  AgentClientOrchestrationAdapter,
   AgentClientManifestEntry,
   AgentClientModelSelectionContext,
   AgentClientProjectDescriptor,