@fitlab-ai/agent-infra 0.9.8 → 0.9.9

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

@@ -1,8 +1,7 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, dispatchOrchestrationDelegation, pauseOrchestration, recoverCommitIntent, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
+import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
 import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -23,26 +22,15 @@ async function taskOrchestration(args = []) {
     const [taskRef, intent] = args;
     if (![
         'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status',
-        'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
+        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
         return;
     }
     const values = {};
     const seen = new Set();
-    let orchestrated = false;
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--orchestrated') {
-            if (seen.has(flag)) {
-                usageFailure(`duplicate option '${flag}'`);
-                return;
-            }
-            seen.add(flag);
-            orchestrated = true;
-            continue;
-        }
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
@@ -52,8 +40,7 @@ async function taskOrchestration(args = []) {
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
             '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
-            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head',
-            '--attempt', '--git-worktree-root'
+            '--git-worktree-root'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -70,33 +57,6 @@ async function taskOrchestration(args = []) {
         }
         values[flag] = value;
     }
-    const commitIntentFlags = {
-        'commit-start': ['--agent', '--git-worktree-root'],
-        'commit-begin': ['--agent', '--baseline-head', '--attempt', '--orchestrated', '--git-worktree-root'],
-        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref', '--git-worktree-root'],
-        'commit-complete': ['--token', '--agent', '--git-worktree-root'],
-        'commit-recover': ['--agent', '--git-worktree-root'],
-        'commit-abort': ['--token', '--expected-head', '--git-worktree-root'],
-        'commit-terminate': ['--attempt', '--agent', '--code', '--git-worktree-root'],
-        'commit-status': ['--git-worktree-root']
-    };
-    if (intent in commitIntentFlags) {
-        const allowed = commitIntentFlags[intent];
-        const invalid = [...seen].find((flag) => !allowed.includes(flag));
-        if (invalid) {
-            usageFailure(`intent '${intent}' does not accept '${invalid}'`);
-            return;
-        }
-    }
-    else {
-        const commitOnly = [...seen].find((flag) => [
-            '--orchestrated', '--baseline-head', '--attempt', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
-        ].includes(flag));
-        if (commitOnly) {
-            usageFailure(`intent '${intent}' does not accept '${commitOnly}'`);
-            return;
-        }
-    }
     const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
     const coreOptions = values['--git-worktree-root'] === undefined
         ? {}
@@ -106,273 +66,178 @@ async function taskOrchestration(args = []) {
         return;
     }
     let result;
-    if (intent === 'commit-start') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-start' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = startCommitAttempt(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-begin') {
-        const missing = requireValues(['--agent', '--baseline-head', '--attempt']);
-        if (missing) {
-            usageFailure(`intent 'commit-begin' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = beginCommitIntent(taskRef, {
-            agent, orchestrated, baselineHead: values['--baseline-head'], attempt: values['--attempt']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-checkpoint') {
-        const missing = requireValues(['--token', '--kind', '--head']);
-        if (missing) {
-            usageFailure(`intent 'commit-checkpoint' requires '${missing}'`);
-            return;
-        }
-        if (!['committed', 'pushed'].includes(values['--kind'])) {
-            usageFailure('--kind must be committed or pushed');
-            return;
-        }
-        if (values['--kind'] === 'pushed') {
-            const pushedMissing = requireValues(['--remote', '--ref']);
-            if (pushedMissing) {
-                usageFailure(`pushed checkpoint requires '${pushedMissing}'`);
+    try {
+        if (intent === 'begin-or-resume') {
+            const missing = requireValues(['--client']);
+            if (missing) {
+                usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
                 return;
             }
+            const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
+            if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
+                usageFailure('--max-steps must be a positive integer');
+                return;
+            }
+            const policyFlags = [
+                '--executor-model', '--executor-reasoning-effort',
+                '--reviewer-model', '--reviewer-reasoning-effort'
+            ];
+            const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
+            if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
+                usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
+                return;
+            }
+            result = beginOrResumeOrchestration(taskRef, {
+                ...coreOptions,
+                maxSteps,
+                client: values['--client'],
+                modelPolicy: hasAnyPolicy ? {
+                    executor: {
+                        model: values['--executor-model'],
+                        reasoningEffort: values['--executor-reasoning-effort']
+                    },
+                    reviewer: {
+                        model: values['--reviewer-model'],
+                        reasoningEffort: values['--reviewer-reasoning-effort']
+                    }
+                } : undefined
+            });
+        }
+        else if (intent === 'route') {
+            result = routeOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'status') {
+            result = statusOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'prepare') {
+            const missing = requireValues(['--client']);
+            if (missing) {
+                usageFailure(`intent 'prepare' requires '${missing}'`);
+                return;
+            }
+            result = await prepareCodexOrchestrationDelegation(taskRef, {
+                client: values['--client'],
+                requestedModel: values['--requested-model'],
+                requestedReasoningEffort: values['--requested-reasoning-effort'],
+                capabilityToken: values['--capability-token']
+            }, { orchestrationOptions: coreOptions });
+        }
+        else if (intent === 'dispatch') {
+            result = dispatchOrchestrationDelegation(taskRef, coreOptions);
+        }
+        else if (intent === 'await-activation') {
+            const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
+            if (missing) {
+                usageFailure(`intent 'await-activation' requires '${missing}'`);
+                return;
+            }
+            const round = Number(values['--round']);
+            if (!Number.isSafeInteger(round) || round < 1) {
+                usageFailure('--round must be a positive integer');
+                return;
+            }
+            if (!['executor', 'reviewer'].includes(values['--role'])) {
+                usageFailure('--role must be executor or reviewer');
+                return;
+            }
+            result = await awaitOrchestrationDelegationActivation(taskRef, {
+                stage: values['--stage'],
+                round,
+                artifact: values['--artifact'],
+                role: values['--role']
+            }, coreOptions);
         }
-        else if (values['--remote'] !== undefined || values['--ref'] !== undefined) {
-            usageFailure('committed checkpoint does not accept --remote or --ref');
-            return;
-        }
-        result = checkpointCommitIntent(taskRef, {
-            token: values['--token'], kind: values['--kind'],
-            head: values['--head'], remote: values['--remote'], ref: values['--ref']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-complete') {
-        const missing = requireValues(['--token', '--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-complete' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = completeCommitIntent(taskRef, { token: values['--token'], agent }, coreOptions);
-    }
-    else if (intent === 'commit-recover') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-recover' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = recoverCommitIntent(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-abort') {
-        const missing = requireValues(['--token', '--expected-head']);
-        if (missing) {
-            usageFailure(`intent 'commit-abort' requires '${missing}'`);
-            return;
-        }
-        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] }, coreOptions);
-    }
-    else if (intent === 'commit-terminate') {
-        const missing = requireValues(['--attempt', '--agent', '--code']);
-        if (missing) {
-            usageFailure(`intent 'commit-terminate' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        if (!/^[A-Z][A-Z0-9_]{2,63}$/.test(values['--code'])) {
-            usageFailure('--code must be a stable uppercase identifier');
-            return;
-        }
-        result = terminateCommitAttempt(taskRef, {
-            attempt: values['--attempt'], agent, code: values['--code']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-status') {
-        result = statusCommitIntent(taskRef, coreOptions);
-    }
-    else if (intent === 'begin-or-resume') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
-            return;
-        }
-        const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
-        if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
-            usageFailure('--max-steps must be a positive integer');
-            return;
-        }
-        const policyFlags = [
-            '--executor-model', '--executor-reasoning-effort',
-            '--reviewer-model', '--reviewer-reasoning-effort'
-        ];
-        const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
-        if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
-            usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
-            return;
-        }
-        result = beginOrResumeOrchestration(taskRef, {
-            ...coreOptions,
-            maxSteps,
-            client: values['--client'],
-            modelPolicy: hasAnyPolicy ? {
-                executor: {
-                    model: values['--executor-model'],
-                    reasoningEffort: values['--executor-reasoning-effort']
-                },
-                reviewer: {
-                    model: values['--reviewer-model'],
-                    reasoningEffort: values['--reviewer-reasoning-effort']
-                }
-            } : undefined
-        });
-    }
-    else if (intent === 'route') {
-        result = routeOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'status') {
-        result = statusOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'prepare') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'prepare' requires '${missing}'`);
-            return;
-        }
-        result = await prepareCodexOrchestrationDelegation(taskRef, {
-            client: values['--client'],
-            requestedModel: values['--requested-model'],
-            requestedReasoningEffort: values['--requested-reasoning-effort'],
-            capabilityToken: values['--capability-token']
-        }, { orchestrationOptions: coreOptions });
-    }
-    else if (intent === 'dispatch') {
-        result = dispatchOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'await-activation') {
-        const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
-        if (missing) {
-            usageFailure(`intent 'await-activation' requires '${missing}'`);
-            return;
-        }
-        const round = Number(values['--round']);
-        if (!Number.isSafeInteger(round) || round < 1) {
-            usageFailure('--round must be a positive integer');
-            return;
-        }
-        if (!['executor', 'reviewer'].includes(values['--role'])) {
-            usageFailure('--role must be executor or reviewer');
-            return;
-        }
-        result = await awaitOrchestrationDelegationActivation(taskRef, {
-            stage: values['--stage'],
-            round,
-            artifact: values['--artifact'],
-            role: values['--role']
-        }, coreOptions);
-    }
-    else if (intent === 'recover-prepared') {
-        result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'hook-start') {
-        const missing = requireValues([
-            ...(taskRef === 'auto' ? ['--client'] : []),
-            '--native-agent', '--child-id', '--parent-id'
-        ]);
-        if (missing) {
-            usageFailure(`intent 'hook-start' requires '${missing}'`);
-            return;
+        else if (intent === 'recover-prepared') {
+            result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
         }
-        const event = {
-            nativeAgent: values['--native-agent'], childId: values['--child-id'],
-            parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
-            actualModel: values['--actual-model'],
-            actualReasoningEffort: values['--actual-reasoning-effort'],
-            modelFallbackReason: values['--model-fallback-reason'],
-            reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-        };
-        result = taskRef === 'auto'
-            ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
-            : activateOrchestrationDelegation(taskRef, event, coreOptions);
-    }
-    else if (intent === 'hook-stop') {
-        if (taskRef === 'auto') {
-            const missing = requireValues(['--client', '--native-agent', '--child-id']);
+        else if (intent === 'hook-start') {
+            const missing = requireValues([
+                ...(taskRef === 'auto' ? ['--client'] : []),
+                '--native-agent', '--child-id', '--parent-id'
+            ]);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'hook-start' requires '${missing}'`);
                 return;
             }
-            result = sealMatchingOrchestrationDelegation(values['--client'], {
+            const event = {
                 nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
                 actualModel: values['--actual-model'],
                 actualReasoningEffort: values['--actual-reasoning-effort'],
                 modelFallbackReason: values['--model-fallback-reason'],
                 reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-            }, coreOptions);
+            };
+            result = taskRef === 'auto'
+                ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
+                : activateOrchestrationDelegation(taskRef, event, coreOptions);
+        }
+        else if (intent === 'hook-stop') {
+            if (taskRef === 'auto') {
+                const missing = requireValues(['--client', '--native-agent', '--child-id']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                result = sealMatchingOrchestrationDelegation(values['--client'], {
+                    nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+            else {
+                const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                const exitCode = Number(values['--exit-code']);
+                if (!Number.isInteger(exitCode)) {
+                    usageFailure('--exit-code must be an integer');
+                    return;
+                }
+                result = sealOrchestrationDelegation(taskRef, {
+                    childId: values['--child-id'], exitCode,
+                    afterFingerprint: values['--after-fingerprint'],
+                    changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+        }
+        else if (intent === 'advance') {
+            result = advanceOrchestration(taskRef, coreOptions);
         }
         else {
-            const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+            const missing = requireValues(['--code', '--message', '--recoverable']);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'pause' requires '${missing}'`);
                 return;
             }
-            const exitCode = Number(values['--exit-code']);
-            if (!Number.isInteger(exitCode)) {
-                usageFailure('--exit-code must be an integer');
+            if (!['true', 'false'].includes(values['--recoverable'])) {
+                usageFailure('--recoverable must be true or false');
                 return;
             }
-            result = sealOrchestrationDelegation(taskRef, {
-                childId: values['--child-id'], exitCode,
-                afterFingerprint: values['--after-fingerprint'],
-                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
-                actualModel: values['--actual-model'],
-                actualReasoningEffort: values['--actual-reasoning-effort'],
-                modelFallbackReason: values['--model-fallback-reason'],
-                reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-            }, coreOptions);
-        }
-    }
-    else if (intent === 'advance') {
-        result = advanceOrchestration(taskRef, coreOptions);
-    }
-    else {
-        const missing = requireValues(['--code', '--message', '--recoverable']);
-        if (missing) {
-            usageFailure(`intent 'pause' requires '${missing}'`);
-            return;
-        }
-        if (!['true', 'false'].includes(values['--recoverable'])) {
-            usageFailure('--recoverable must be true or false');
-            return;
-        }
-        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+            result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OrchestrationStateError))
+            throw error;
+        result = {
+            status: 'failed',
+            changed: false,
+            taskId: error.taskId,
+            run: null,
+            next: null,
+            error: { code: error.code, message: error.message }
+        };
     }
-    process.stdout.write(`${JSON.stringify(result)}\n`);
+    const output = result;
+    process.stdout.write(`${JSON.stringify(output)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;
 }

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

@@ -8,6 +8,13 @@ import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
 import { listRemoteComments, normalizeCommentContent, writeComment } from './issue-comments.js';
 import { platformResult } from './types.js';
+function warningResultForPrimary(primaryResult) {
+    if (primaryResult === 'pr_created')
+        return 'pr_created_with_warnings';
+    if (primaryResult === 'pr_reused')
+        return 'pr_reused_with_warnings';
+    return 'no_op_with_warnings';
+}
 function summaryMarker(taskId) {
     return `<!-- sync-pr:${taskId}:summary -->`;
 }
@@ -51,40 +58,71 @@ function summaryContext(taskRef, options = {}) {
     return { ...platformResult('no-op'), task: { id: resolved.taskId, prNumber }, artifacts: canonicalArtifacts(resolved.taskDir) };
 }
 function syncPullRequestSummary(taskRef, options) {
+    const warningResult = warningResultForPrimary(options.primaryResult);
+    let knownPrNumber = null;
+    const softenFailure = (output) => {
+        const prNumber = output.resource.kind === 'pull-request' && output.resource.number
+            ? output.resource.number
+            : knownPrNumber;
+        const warning = output.error && prNumber
+            && output.error.code !== 'PR_NOT_LINKED'
+            ? {
+                code: output.error.code,
+                message: output.error.message,
+                retryable: output.error.retryable,
+                step: 'pr-summary',
+                target: `pull-request:${prNumber}`,
+                severity: 'ACTION_REQUIRED'
+            }
+            : null;
+        return warning
+            ? {
+                ...output,
+                status: 'applied',
+                changed: false,
+                resource: { kind: 'pull-request', number: prNumber },
+                error: null,
+                result: warningResult,
+                warnings: [warning]
+            }
+            : { ...output, result: null, warnings: [] };
+    };
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
-        return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
+        return softenFailure(platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }));
     const frontmatter = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
     const prNumber = Number(frontmatter.pr_number);
     if (!Number.isInteger(prNumber) || prNumber <= 0)
-        return platformResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } });
+        return softenFailure(platformResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } }));
+    knownPrNumber = prNumber;
     const client = options.client || createGitHubClient();
     const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
     if (!context.platform.repository || !['no-op', 'degraded'].includes(context.status))
-        return context;
+        return softenFailure(context);
     let headSha;
     try {
         headSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: resolved.repoRoot, encoding: 'utf8' }).trim();
     }
     catch (error) {
-        return platformResult('failed', { platform: context.platform, capabilities: context.capabilities, error: { code: 'GIT_HEAD_UNRESOLVED', message: error instanceof Error ? error.message : String(error), retryable: false } });
+        return softenFailure(platformResult('failed', { platform: context.platform, capabilities: context.capabilities, error: { code: 'GIT_HEAD_UNRESOLVED', message: error instanceof Error ? error.message : String(error), retryable: false } }));
     }
     const desired = buildPullRequestSummary(resolved.taskId, options.body, headSha, renderHumanOverrideAudit(fs.readFileSync(resolved.taskMdPath, 'utf8')));
     const listed = listRemoteComments(client, context.platform.repository, prNumber, resolved.repoRoot);
     if (!listed.ok)
-        return platformResult(listed.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: listed.error });
+        return softenFailure(platformResult(listed.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: listed.error }));
     const reconciliation = reconcileSummaryComment(listed.value, resolved.taskId, desired);
     if (reconciliation.action === 'conflict')
-        return platformResult('failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: { code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple PR comments contain the summary marker', retryable: false } });
+        return softenFailure(platformResult('failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: { code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple PR comments contain the summary marker', retryable: false } }));
     if (reconciliation.action === 'no-op')
-        return platformResult('no-op', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: [reconciliation.commentId], parts: 1 }, error: null });
+        return softenFailure(platformResult('no-op', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: [reconciliation.commentId], parts: 1 }, error: null }));
     if (options.dryRun)
-        return platformResult('planned', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, operations: [{ name: `summary:${reconciliation.action}`, status: 'planned', reasonCode: null }], error: null });
+        return softenFailure(platformResult('planned', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, operations: [{ name: `summary:${reconciliation.action}`, status: 'planned', reasonCode: null }], error: null }));
     const written = writeComment(client, context.platform.repository, prNumber, resolved.repoRoot, desired, reconciliation.commentId || undefined);
     if (!written.ok)
-        return platformResult(written.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: written.error });
+        return softenFailure(platformResult(written.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: written.error }));
     const id = Number(written.value.id || reconciliation.commentId);
-    return platformResult('applied', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 }, operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }], error: null });
+    return softenFailure(platformResult('applied', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 }, operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }], error: null }));
 }
 export { buildPullRequestSummary, reconcileSummaryComment, summaryContext, summaryMarker, syncPullRequestSummary };
+export { warningResultForPrimary };
 //# sourceMappingURL=pr-summary.js.map