@fitlab-ai/agent-infra 0.9.2 → 0.9.3

package/dist/lib/internal/pr-review-grade.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { collectHostCandidates, decide, deriveTaskIssueMatches, extractClosingIssueNumbers, resolveHostFromCandidates } from '../pr-review/evidence-grading.js';
+import { inspectPlatformPullRequestByNumber } from '../platform/pull-requests.js';
+import { verifyInProcess } from '../task/verification-engine.js';
+const USAGE = `Usage: agent-infra-internal pr-review-grade decide --input-file <path|-> [--cwd <path>]
+       agent-infra-internal pr-review-grade resolve-host --pr <N> [--cwd <path>]
+       agent-infra-internal pr-review-grade verify-artifact --artifact-file <path> [--cwd <path>]
+`;
+function fail(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'PR_REVIEW_GRADE_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function finish(result, exitCode = 0) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
+}
+function parseFlags(args, start) {
+    const values = {};
+    const seen = new Set();
+    for (let index = start; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!['--input-file', '--artifact-file', '--cwd', '--pr'].includes(flag)) {
+            return { values, error: `unknown option '${flag}'` };
+        }
+        if (seen.has(flag))
+            return { values, error: `duplicate option '${flag}'` };
+        seen.add(flag);
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--'))
+            return { values, error: `option '${flag}' requires a value` };
+        values[flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+    }
+    return { values };
+}
+function readInput(value, cwd) {
+    return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
+}
+function prReviewGrade(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const operation = args[0];
+    if (!operation || !['decide', 'resolve-host', 'verify-artifact'].includes(operation)) {
+        fail('a valid operation is required');
+        return;
+    }
+    const parsed = parseFlags(args, 1);
+    if (parsed.error) {
+        fail(parsed.error);
+        return;
+    }
+    const values = parsed.values;
+    const cwd = path.resolve(typeof values.cwd === 'string' ? values.cwd : process.cwd());
+    const allowed = {
+        decide: ['cwd', 'inputFile'],
+        'resolve-host': ['cwd', 'pr'],
+        'verify-artifact': ['cwd', 'artifactFile']
+    };
+    const unexpected = Object.keys(values).find((key) => !allowed[operation].includes(key));
+    if (unexpected) {
+        fail(`${operation} does not accept '--${unexpected}'`);
+        return;
+    }
+    if (operation === 'decide') {
+        if (typeof values.inputFile !== 'string') {
+            fail('decide requires --input-file');
+            return;
+        }
+        let input;
+        try {
+            input = JSON.parse(readInput(values.inputFile, cwd));
+        }
+        catch (error) {
+            fail(`unable to read decide input: ${error instanceof Error ? error.message : String(error)}`);
+            return;
+        }
+        try {
+            const record = decide(input);
+            finish(record);
+        }
+        catch (error) {
+            const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : 'DECIDE_FAILED';
+            finish({ status: 'failed', changed: false, error: { code, message: error instanceof Error ? error.message : String(error) } }, 1);
+        }
+        return;
+    }
+    if (operation === 'resolve-host') {
+        const pr = Number(values.pr);
+        if (!Number.isInteger(pr) || pr <= 0) {
+            fail('resolve-host requires a positive --pr');
+            return;
+        }
+        const inspected = inspectPlatformPullRequestByNumber(pr, { cwd });
+        if (!inspected.pullRequest) {
+            finish({
+                status: 'failed', changed: false, host: null, candidates: [], closingIssues: [],
+                error: inspected.error ?? { code: 'PR_INSPECTION_INVALID', message: 'unable to inspect the pull request', retryable: false }
+            }, inspected.status === 'blocked' ? 2 : 1);
+            return;
+        }
+        const closingIssues = extractClosingIssueNumbers(inspected.pullRequest.body);
+        const candidates = collectHostCandidates({ prNumber: pr, closingIssues, workspaceRoot: cwd });
+        const host = resolveHostFromCandidates(candidates);
+        finish({
+            status: 'ok', changed: false,
+            pr: { number: pr, baseSha: inspected.pullRequest.base.sha, headSha: inspected.pullRequest.head.sha, state: inspected.pullRequest.state },
+            closingIssues, candidates, host,
+            taskIssueMatches: deriveTaskIssueMatches(host, closingIssues), error: null
+        });
+        return;
+    }
+    if (typeof values.artifactFile !== 'string') {
+        fail('verify-artifact requires --artifact-file');
+        return;
+    }
+    const artifactPath = path.resolve(cwd, values.artifactFile);
+    let result;
+    try {
+        result = verifyInProcess({
+            mode: 'checks',
+            skillName: 'review-pr',
+            taskDir: path.dirname(artifactPath),
+            artifactFile: path.basename(artifactPath),
+            checks: ['artifact'],
+            repositoryRoot: cwd
+        });
+    }
+    catch (error) {
+        finish({ status: 'failed', changed: false, error: { code: 'VERIFY_ARTIFACT_INVALID', message: error instanceof Error ? error.message : String(error) } }, 1);
+        return;
+    }
+    const status = result.status;
+    finish(result, { pass: 0, fail: 1, blocked: 2 }[status]);
+}
+export { prReviewGrade };
+//# sourceMappingURL=pr-review-grade.js.map

package/dist/lib/internal/release-workflow.js

@@ -139,9 +139,10 @@ function runOptionalDemo(cwd, run = command) {
     writeDigestAtomically(cwd, digest);
     return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
-function git(cwd, args, run = command) {
+function git(cwd, args, run = command, trim = true) {
     const result = run(cwd, 'git', args);
-    return result.status === 0 ? String(result.stdout).trim() : null;
+    const stdout = String(result.stdout);
+    return result.status === 0 ? (trim ? stdout.trim() : stdout) : null;
 }
 function inspectLocalReleaseFacts(cwd, version, run = command) {
     const tag = `v${version}`;
@@ -216,9 +217,15 @@ async function inspectFacts(cwd, version) {
         npm: npm.published, homebrew: homebrew.published, smoke
     };
 }
-function changedPaths(cwd) {
-    const output = git(cwd, ['status', '--porcelain=v1']) || '';
-    return output.split('\n').filter(Boolean).map((line) => line.slice(3)).filter((value, index, all) => all.indexOf(value) === index);
+function parsePorcelainPath(record) {
+    const match = /^.. (.+)$/.exec(record);
+    if (!match)
+        throw new Error('Invalid git status --porcelain=v1 record');
+    return match[1];
+}
+function changedPaths(cwd, run = command) {
+    const output = git(cwd, ['status', '--porcelain=v1'], run, false) || '';
+    return output.split(/\r?\n/).filter(Boolean).map(parsePorcelainPath).filter((value, index, all) => all.indexOf(value) === index);
 }
 function updateReleaseMetadata(cwd, version) {
     const [major = '0', minor = '0'] = version.split('.');
@@ -371,5 +378,5 @@ async function releaseWorkflow(args = []) {
     process.stdout.write(`${JSON.stringify({ ...pushed, demo, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`);
     process.exitCode = pushed.status === 'failed' ? 1 : pushed.status === 'degraded' ? 2 : 0;
 }
-export { computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

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

@@ -0,0 +1,73 @@
+import { applyActivityAppendIntent } from '../task/activity-intent.js';
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> append --step <step> --agent <agent> --note <note> [--artifact <canonical.md>] [--dry-run]
+`;
+const FLAGS = {
+    '--step': 'step',
+    '--agent': 'agent',
+    '--note': 'note',
+    '--artifact': 'artifact'
+};
+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 || kind !== 'append') {
+        usageFailure('task ref and the append 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] = value;
+    }
+    const allowed = new Set(['kind', 'taskRef', 'dryRun', 'step', 'agent', 'note', 'artifact']);
+    const unexpected = Object.keys(values).find((key) => !allowed.has(key));
+    if (unexpected) {
+        usageFailure(`append does not accept '${unexpected}'`);
+        return;
+    }
+    for (const key of ['step', 'agent', 'note']) {
+        if (values[key] === undefined) {
+            usageFailure(`append requires '${key}'`);
+            return;
+        }
+    }
+    const result = applyActivityAppendIntent(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-lifecycle.js

@@ -1,3 +1,4 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.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 = {
@@ -49,6 +50,12 @@ function taskLifecycle(args = []) {
         seen.add(flag);
         values[key] = key === 'alertNumber' || key === 'issueNumber' ? Number(value) : value;
     }
+    const agent = normalizeAgentToken(String(values.agent ?? ''));
+    if (!agent) {
+        usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`);
+        return;
+    }
+    values.agent = agent;
     const result = applyTaskLifecycle(values);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')

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

@@ -1,4 +1,6 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginOrResumeOrchestration, completeCommitOrchestrationStage, pauseOrchestration, prepareOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, 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|stage-completed|hook-stop|advance|pause|status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
@@ -27,8 +29,11 @@ function taskOrchestration(args = []) {
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
         if (![
-            '--max-steps', '--client', '--requested-model', '--parent-id', '--before-fingerprint',
-            '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--fallback-reason',
+            '--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'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
@@ -47,14 +52,45 @@ function taskOrchestration(args = []) {
         values[flag] = value;
     }
     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') {
+        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 +106,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 +122,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)
@@ -126,7 +166,12 @@ function taskOrchestration(args = []) {
             usageFailure(`intent 'stage-completed' requires '${missing}'`);
             return;
         }
-        result = completeCommitOrchestrationStage(taskRef, values['--agent']);
+        const agent = normalizeAgentToken(values['--agent']);
+        if (!agent) {
+            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
+            return;
+        }
+        result = completeCommitOrchestrationStage(taskRef, 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

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

@@ -19,7 +19,8 @@ const ARTIFACT_TITLES = {
     'review-plan': '技术方案审查',
     code: '实现报告',
     'review-code': '代码审查',
-    'manual-validation': '人工验证报告'
+    'manual-validation': '人工验证报告',
+    'pr-review': 'PR 审查报告'
 };
 function normalizeCommentContent(content) {
     return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
@@ -51,7 +52,7 @@ function renderTaskComment(content, taskId, agent) {
 }
 function artifactIdentity(artifact) {
     const stem = path.basename(artifact, '.md');
-    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation)(?:-r(\d+))?$/);
+    const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|pr-review)(?:-r(\d+))?$/);
     if (!match)
         throw new Error(`unsupported artifact '${artifact}'`);
     const base = ARTIFACT_TITLES[match[1]];