@fitlab-ai/agent-infra 0.9.2 → 0.9.4

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

@@ -0,0 +1,105 @@
+import { applyPrReviewActivityIntent, inspectPrReviewActivity } from '../task/activity-intent.js';
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> pr-review-inspect
+       agent-infra-internal task-activity <task-ref> pr-review-start --agent <agent> --artifact <canonical.md> --head <40hex> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-complete --agent <agent> --artifact <canonical.md> --head <40hex> --verdict <approved|changes-requested|commented> --blockers <N> --major <N> --minor <N> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-terminate --agent <agent> --artifact <canonical.md> --head <40hex> --outcome <aborted|superseded> --reason <single-line> [--dry-run]
+`;
+const OPERATIONS = new Set(['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate']);
+const FLAGS = {
+    '--agent': 'agent',
+    '--artifact': 'artifact',
+    '--head': 'head',
+    '--verdict': 'verdict',
+    '--blockers': 'blockers',
+    '--major': 'major',
+    '--minor': 'minor',
+    '--outcome': 'outcome',
+    '--reason': 'reason'
+};
+const COMMON = ['agent', 'artifact', 'head'];
+const ALLOWED = {
+    'pr-review-inspect': new Set(['kind', 'taskRef']),
+    'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun']),
+    'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun']),
+    'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun'])
+};
+function usageFailure(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function taskActivity(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const [taskRef, kind] = args;
+    if (!taskRef || taskRef.startsWith('--') || !kind || !OPERATIONS.has(kind)) {
+        usageFailure('task ref and a supported PR review intent are required');
+        return;
+    }
+    const values = { kind, taskRef };
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--dry-run') {
+            if (seen.has(flag)) {
+                usageFailure(`duplicate option '${flag}'`);
+                return;
+            }
+            seen.add(flag);
+            values.dryRun = true;
+            continue;
+        }
+        const key = FLAGS[flag];
+        if (!key) {
+            usageFailure(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            usageFailure(`duplicate option '${flag}'`);
+            return;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--')) {
+            usageFailure(`option '${flag}' requires a value`);
+            return;
+        }
+        seen.add(flag);
+        values[key] = ['blockers', 'major', 'minor'].includes(key) ? Number(value) : value;
+    }
+    const allowed = ALLOWED[kind];
+    const unexpected = Object.keys(values).find((key) => !allowed.has(key));
+    if (unexpected) {
+        usageFailure(`${kind} does not accept '${unexpected}'`);
+        return;
+    }
+    if (kind === 'pr-review-inspect') {
+        const result = inspectPrReviewActivity(values);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
+        return;
+    }
+    for (const key of COMMON) {
+        if (values[key] === undefined) {
+            usageFailure(`${kind} requires '${key}'`);
+            return;
+        }
+    }
+    const operationRequired = kind === 'pr-review-complete'
+        ? ['verdict', 'blockers', 'major', 'minor']
+        : kind === 'pr-review-terminate' ? ['outcome', 'reason'] : [];
+    for (const key of operationRequired) {
+        if (values[key] === undefined) {
+            usageFailure(`${kind} requires '${key}'`);
+            return;
+        }
+    }
+    const result = applyPrReviewActivityIntent(values);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskActivity };
+//# sourceMappingURL=task-activity.js.map

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

@@ -1,5 +1,6 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskEvent, eventCatalog } from '../task/events.js';
-const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--dry-run]
+const USAGE = `Usage: agent-infra-internal task-event <N | TASK-id> <event> --agent <agent> [event options] [--orchestrated] [--dry-run]
 
 Apply one closed-set task lifecycle event and print a structured JSON result.
 Events: ${eventCatalog.join(', ')}
@@ -30,6 +31,15 @@ function taskEvent(args = []) {
     const seen = new Set();
     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);
+            request.orchestrated = true;
+            continue;
+        }
         if (flag === '--dry-run') {
             if (seen.has(flag)) {
                 usageFailure(`duplicate option '${flag}'`);
@@ -61,6 +71,12 @@ function taskEvent(args = []) {
         else
             request[key] = value;
     }
+    const agent = normalizeAgentToken(String(request.agent ?? ''));
+    if (!agent) {
+        usageFailure(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    request.agent = agent;
     const result = applyTaskEvent(request);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

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

@@ -6,9 +6,10 @@ const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [inte
 const FLAGS = {
     '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
     '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
-    '--status': 'status', '--artifact': 'artifact'
+    '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
+const BOOLEAN = new Set(['needsImplementation']);
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LEDGER_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -55,8 +56,12 @@ function taskLedger(args = []) {
             usageFailure(`option '${flag}' requires a value`);
             return;
         }
+        if (BOOLEAN.has(key) && value !== 'true' && value !== 'false') {
+            usageFailure(`option '${flag}' must be true or false`);
+            return;
+        }
         seen.add(flag);
-        values[key] = NUMERIC.has(key) ? Number(value) : value;
+        values[key] = NUMERIC.has(key) ? Number(value) : BOOLEAN.has(key) ? value === 'true' : value;
     }
     const required = {
         'finding-upsert': ['stage', 'reviewArtifact', 'ordinal', 'severity', 'evidence'],
@@ -66,7 +71,11 @@ function taskLedger(args = []) {
         'decision-upsert': ['id', 'stage', 'artifact'],
         'stage-status': ['stage']
     };
-    const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]]);
+    const optional = {
+        'finding-review': ['needsImplementation'],
+        'decision-upsert': ['needsImplementation']
+    };
+    const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...(optional[kind] ?? [])]);
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     const missing = required[kind].find((key) => values[key] === undefined);
     if (unexpected) {

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

@@ -1,4 +1,7 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\n`;
 const FLAGS = {
     '--agent': 'agent', '--reason': 'reason', '--unblock-condition': 'unblockCondition',
@@ -49,7 +52,29 @@ function taskLifecycle(args = []) {
         seen.add(flag);
         values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
     }
-    const result = applyTaskLifecycle(values);
+    const agent = normalizeAgentToken(String(values.agent ?? ''));
+    if (!agent) {
+        usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    values.agent = agent;
+    const resolved = resolveTaskRef(String(values.taskRef));
+    if (!resolved.ok) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    let result;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-lifecycle.${String(values.intent)}`, () => applyTaskLifecycle(values));
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

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

@@ -1,5 +1,7 @@
-import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginOrResumeOrchestration, completeCommitOrchestrationStage, pauseOrchestration, prepareOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|hook-start|stage-completed|hook-stop|advance|pause|status> [options]\n';
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
+import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, prepareOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusCommitIntent, statusOrchestration } from '../task/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|hook-start|hook-stop|advance|pause|status|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -18,18 +20,35 @@ function taskOrchestration(args = []) {
         return;
     }
     const [taskRef, intent] = args;
-    if (!['begin-or-resume', 'route', 'prepare', 'hook-start', 'stage-completed', 'hook-stop', 'advance', 'pause', 'status'].includes(intent)) {
+    if (![
+        'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
+        'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-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', '--client', '--requested-model', '--parent-id', '--before-fingerprint',
-            '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--fallback-reason',
-            '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent'
+            '--max-steps', '--executor-model', '--executor-reasoning-effort',
+            '--reviewer-model', '--reviewer-reasoning-effort',
+            '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
+            '--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'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -46,15 +65,149 @@ function taskOrchestration(args = []) {
         }
         values[flag] = value;
     }
+    const commitIntentFlags = {
+        'commit-begin': ['--agent', '--baseline-head', '--orchestrated'],
+        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref'],
+        'commit-complete': ['--token', '--agent'],
+        'commit-recover': ['--agent'],
+        'commit-abort': ['--token', '--expected-head'],
+        'commit-status': []
+    };
+    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', '--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);
+    if (values['--client'] !== undefined && !isAgentClientId(values['--client'])) {
+        usageFailure(`unknown client '${values['--client']}'`);
+        return;
+    }
     let result;
-    if (intent === 'begin-or-resume') {
+    if (intent === 'commit-begin') {
+        const missing = requireValues(['--agent', '--baseline-head']);
+        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']
+        });
+    }
+    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}'`);
+                return;
+            }
+        }
+        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']
+        });
+    }
+    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 });
+    }
+    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 });
+    }
+    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'] });
+    }
+    else if (intent === 'commit-status') {
+        result = statusCommitIntent(taskRef);
+    }
+    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;
         }
-        result = beginOrResumeOrchestration(taskRef, { maxSteps });
+        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, {
+            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);
@@ -70,7 +223,8 @@ function taskOrchestration(args = []) {
         }
         result = prepareOrchestrationDelegation(taskRef, {
             client: values['--client'],
-            requestedModel: values['--requested-model']
+            requestedModel: values['--requested-model'],
+            requestedReasoningEffort: values['--requested-reasoning-effort']
         });
     }
     else if (intent === 'hook-start') {
@@ -85,7 +239,10 @@ function taskOrchestration(args = []) {
         const event = {
             nativeAgent: values['--native-agent'], childId: values['--child-id'],
             parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
-            actualModel: values['--actual-model'], modelFallbackReason: values['--fallback-reason']
+            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)
@@ -120,14 +277,6 @@ function taskOrchestration(args = []) {
             });
         }
     }
-    else if (intent === 'stage-completed') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'stage-completed' requires '${missing}'`);
-            return;
-        }
-        result = completeCommitOrchestrationStage(taskRef, values['--agent']);
-    }
     else if (intent === 'advance') {
         result = advanceOrchestration(taskRef);
     }

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

@@ -1,5 +1,5 @@
 import { finalizeReviewSummary } from '../task/review-finalization.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--dry-run]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -26,10 +26,11 @@ function taskReview(args = []) {
     let stage = '';
     let artifact = '';
     let dryRun = false;
+    let orchestrated = false;
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (!['--stage', '--artifact', '--dry-run'].includes(flag)) {
+        if (!['--stage', '--artifact', '--orchestrated', '--dry-run'].includes(flag)) {
             failUsage(`unknown option '${flag}'`);
             return;
         }
@@ -42,6 +43,10 @@ function taskReview(args = []) {
             dryRun = true;
             continue;
         }
+        if (flag === '--orchestrated') {
+            orchestrated = true;
+            continue;
+        }
         const value = args[++index];
         if (!value || value.startsWith('--')) {
             failUsage(`option '${flag}' requires a value`);
@@ -56,7 +61,7 @@ function taskReview(args = []) {
         failUsage("options '--stage' and '--artifact' are required");
         return;
     }
-    const result = finalizeReviewSummary({ taskRef: args[0], stage, artifact, dryRun });
+    const result = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun });
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

package/dist/lib/platform/adapters.js

@@ -17,10 +17,17 @@ function hasPlatformCapability(type, capability) {
     const adapter = getPlatformAdapter(type);
     if (capability === 'change-request')
         return typeof adapter?.inspectChangeRequest === 'function';
+    if (capability === 'issue-closing-change-requests')
+        return typeof adapter?.inspectIssueClosingChangeRequests === 'function';
     if (capability === 'required-checks')
         return typeof adapter?.inspectRequiredChecks === 'function';
     return typeof adapter?.resolveChangeRequestGitEvidence === 'function';
 }
+function inspectPlatformIssueClosingChangeRequests(type, context) {
+    const adapter = getPlatformAdapter(type);
+    return adapter?.inspectIssueClosingChangeRequests?.(context) ??
+        unsupported(type, 'issue closing change-request inspection');
+}
 function unsupported(type, capability) {
     return {
         ok: false,
@@ -47,5 +54,5 @@ function resolvePlatformChangeRequestGitEvidence(type, context) {
 function listPlatformAdapters() {
     return [...adapters.keys()].sort();
 }
-export { getPlatformAdapter, hasPlatformCapability, inspectPlatformChangeRequest, inspectPlatformRequiredChecks, listPlatformAdapters, registerPlatformAdapter, registerPlatformCapabilities, resolvePlatformChangeRequestGitEvidence };
+export { getPlatformAdapter, hasPlatformCapability, inspectPlatformChangeRequest, inspectPlatformIssueClosingChangeRequests, inspectPlatformRequiredChecks, listPlatformAdapters, registerPlatformAdapter, registerPlatformCapabilities, resolvePlatformChangeRequestGitEvidence };
 //# sourceMappingURL=adapters.js.map

package/dist/lib/platform/completion-backfill.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPLETION_BACKFILL_FAMILIES, inspectCompletionArtifacts } from '../task/finalization-artifacts.js';
+import { parseArtifactName } from '../task/artifact-lifecycle.js';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { getOpenWorkflowWarnings } from '../task/workflow-warnings.js';
+import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js';
+import { captureTaskWriteMetadata } from '../task/write.js';
+import { syncPlatformComment } from './issue-comments.js';
+import { platformResult } from './types.js';
+function result(base, artifacts, warnings) {
+    return { ...base, artifacts, warnings };
+}
+function excludedPrReview(taskDir, message) {
+    const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])(pr-review(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
+        .map((match) => match[1]);
+    if (names.length !== 1)
+        return null;
+    const parsed = parseArtifactName(names[0]);
+    if (!parsed || parsed.family !== 'pr-review')
+        return null;
+    const artifactPath = path.join(taskDir, parsed.name);
+    try {
+        const stat = fs.lstatSync(artifactPath);
+        return stat.isFile() && !stat.isSymbolicLink() ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+function backfillCompletionComments(taskRef, options) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return result(platformResult('failed', {
+            error: { code: resolved.code, message: resolved.message, retryable: false }
+        }), [], []);
+    const inventory = inspectCompletionArtifacts(resolved.taskId, { repoRoot: resolved.repoRoot });
+    if (inventory.status === 'failed')
+        return result(platformResult('failed', {
+            error: {
+                code: inventory.error?.code || 'ARTIFACT_TOPOLOGY_CONFLICT',
+                message: inventory.error?.message || 'Completion artifact inventory failed',
+                retryable: false
+            }
+        }), [], []);
+    const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const issueNumber = Number(parseTaskFrontmatter(initialContent).issue_number);
+    if (!Number.isInteger(issueNumber) || issueNumber <= 0)
+        return result(platformResult('no-op', {
+            error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+        }), [], []);
+    const artifacts = [];
+    const operations = [];
+    let latest = platformResult('no-op', { error: null });
+    for (const artifact of inventory.artifacts) {
+        latest = syncPlatformComment(resolved.taskId, {
+            kind: 'artifact',
+            artifact: artifact.name,
+            agent: options.agent,
+            backfill: true,
+            cwd: resolved.repoRoot,
+            client: options.client
+        });
+        operations.push(...latest.operations.map((operation) => ({
+            ...operation,
+            name: `${artifact.name}:${operation.name}`
+        })));
+        artifacts.push({ artifact: artifact.name, status: latest.status });
+        if (latest.status === 'failed' || latest.status === 'blocked')
+            return result({ ...latest, operations }, artifacts, []);
+        if (latest.error)
+            return result(platformResult(latest.error.retryable ? 'blocked' : 'failed', {
+                platform: latest.platform,
+                resource: latest.resource,
+                capabilities: latest.capabilities,
+                operations,
+                error: latest.error
+            }), artifacts, []);
+    }
+    const matching = getOpenWorkflowWarnings(initialContent).flatMap((warning) => {
+        if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact')
+            return [];
+        const excluded = excludedPrReview(resolved.taskDir, warning.message);
+        return excluded ? [{ warning, excluded }] : [];
+    });
+    const warnings = [];
+    let metadata = null;
+    for (const { warning, excluded } of matching) {
+        metadata ??= captureTaskWriteMetadata();
+        const resolution = [
+            `excluded=${excluded}`,
+            `completionFamilies=${COMPLETION_BACKFILL_FAMILIES.join(',')}`,
+            `synchronized=${inventory.artifacts.map((artifact) => artifact.name).join(',') || 'none'}`,
+            `completedAt=${metadata.timestamp}`
+        ].join('; ');
+        const updated = applyWorkflowWarningIntent({
+            kind: 'set-status', taskRef: resolved.taskId, id: warning.id, status: 'resolved', resolution
+        }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata });
+        if (updated.status === 'failed')
+            return result(platformResult('failed', {
+                platform: latest.platform,
+                resource: latest.resource,
+                capabilities: latest.capabilities,
+                operations,
+                changed: artifacts.some((item) => item.status === 'applied'),
+                error: { code: updated.error?.code || 'WARNING_UPDATE_FAILED', message: updated.error?.message || 'Unable to resolve workflow warning', retryable: false }
+            }), artifacts, warnings);
+        warnings.push({ id: warning.id, status: updated.status });
+    }
+    const changed = artifacts.some((item) => item.status === 'applied') || warnings.some((item) => item.status === 'applied');
+    return result(platformResult(changed ? 'applied' : 'no-op', {
+        platform: latest.platform,
+        resource: latest.resource,
+        capabilities: latest.capabilities,
+        changed,
+        operations,
+        error: null
+    }), artifacts, warnings);
+}
+export { backfillCompletionComments };
+//# sourceMappingURL=completion-backfill.js.map