@fitlab-ai/agent-infra 0.11.3 → 0.11.4

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <strong>From issue to merged PR in 11 commands.</strong> Define a requirement, let AI handle analysis, planning, coding, and three-stage review — you only step in when it matters.
+  <strong>From issue to merged PR through a risk-selected lifecycle.</strong> Every task starts with analysis, and every implementation receives an independent code review.
 </p>
 
 <p align="center">
@@ -51,14 +51,22 @@ Once initialized, open the project in your AI TUI and install the latest skills:
 
 > AI reads `.agents/.airc.json`, auto-locates the installed template root, and syncs the latest skill manifests, managed files, and registry deterministically via `sync-templates.js`.
 
-**Scenario**: Issue #42 reports *"Login API returns 500 when email contains a plus sign"*. Here is the full fix lifecycle — AI does the heavy lifting, you stay in control:
+**Scenario**: Issue #42 reports *"Login API returns 500 when email contains a plus sign"*. Every task starts with analysis, which records one canonical path from observable facts:
+
+| Path | Stages | Use when |
+|------|--------|----------|
+| Streamlined | `analyze → code → review-code` | Scope and acceptance are clear, with no separate design or document-audit decision |
+| Standard | `analyze → plan → code → review-code` | The implementation needs an explicit cross-module contract, data flow, or test strategy |
+| Full | `analyze → review-analysis → plan → review-plan → code → review-code` | Concrete acceptance disputes, costly interface/schema/migration choices, or real external/security boundaries require independent review |
+
+File count, module count, or a merely possible risk does not select the full path. A later finding can return work to analysis, planning, or code when new evidence justifies it; independent `review-code` remains part of every path.
+
+Suppose the analysis selects the **standard path** because the application-layer boundary needs an explicit plan:
 
 ```bash
 /import-issue 42           # AI reads the issue, creates a task, extracts requirements
-/analyze-task --task <task-id>    # AI scans the codebase, finds the root cause, writes analysis.md
-/review-analysis --task <task-id> # An isolated reviewer checks the analysis
+/analyze-task --task <task-id>    # AI scans the codebase, records the selected path, writes analysis.md
 /plan-task --task <task-id>       # AI proposes a fix plan
-/review-plan --task <task-id>     # A fresh isolated reviewer checks the plan
 ```
 
 > **You review the plan and reply in natural language:**
@@ -79,7 +87,7 @@ Just fix it at the application layer in LoginService.
 /complete-task --task <task-id>   # task archived
 ```
 
-**11 commands. 1 natural-language correction. From issue to merged PR.** That is the entire SOP — programming can have a standard operating procedure too.
+**One analysis-selected path, one natural-language correction, and an independent code review.** The lifecycle keeps the evidence and review depth proportional to the task.
 
 Every command above works the same way in Claude Code, Codex, Antigravity CLI, and OpenCode. Switch tools mid-task — the workflow state follows. For what each skill does under the hood, see [Built-in AI Skills](./docs/en/skills.md).
 
@@ -193,8 +201,9 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 |---------|---------|
 | `create-task` / `import-issue` | Start a task from a description or a GitHub Issue |
 | `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; Codex now has an experimental Hooks + App Server evidence channel, but orchestration remains disabled until that channel is connected to delegation receipts |
-| `analyze-task` → `review-analysis` | Capture scope and risks, then review the analysis |
-| `plan-task` → `review-plan` | Design the approach, then review the plan |
+| `analyze-task` | Capture scope and risks, then select the streamlined, standard, or full path |
+| `review-analysis` | Review the analysis when the selected full path requires an independent requirement checkpoint |
+| `plan-task` / `review-plan` | Design the approach on standard/full paths; independently review it only on the full path |
 | `code-task` → `review-code` | Implement and test; `code-task` creates a local checkpoint, then a structured review checks that checkpoint |
 | `create-pr` → `complete-task` | Publish the approved checkpoint to the task-bound target branch, then archive after merge and final gates |
 

package/README.zh-CN.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <strong>从 Issue 到合并 PR，只需 11 条命令。</strong> 定义需求，让 AI 完成分析、方案设计、编码与三阶段审查 —— 你只需在关键节点介入。
+  <strong>从 Issue 到合并 PR，由风险选择相称的生命周期。</strong> 每个任务都先分析，每份实现都接受独立代码审查。
 </p>
 
 <p align="center">
@@ -50,14 +50,22 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 
 > AI 读取 `.agents/.airc.json`，自动定位已安装的模板根目录，并通过 `sync-templates.js` 确定性地同步最新的 skill 清单、managed 文件和注册表。
 
-**场景**：Issue #42 报告 *"登录接口在邮箱包含加号时返回 500"*。以下是完整的修复流程 —— AI 执行主要工作，你掌控方向：
+**场景**：Issue #42 报告 *"登录接口在邮箱包含加号时返回 500"*。每个任务都从分析开始，并由分析根据可观察事实记录一条规范路径：
+
+| 路径 | 阶段 | 适用条件 |
+|------|------|----------|
+| 精简路径 | `analyze → code → review-code` | 范围和验收明确，不需要独立设计或文档审计决策 |
+| 标准路径 | `analyze → plan → code → review-code` | 实现需要明确跨模块契约、数据流或测试策略 |
+| 完整路径 | `analyze → review-analysis → plan → review-plan → code → review-code` | 存在具体的验收争议、高代价接口/schema/迁移选择，或真实外部/安全边界，需要独立审查 |
+
+文件数量、模块数量或可能存在的风险不能单独触发完整路径。后续 finding 只有在新证据成立时才会把工作返回分析、方案或实现阶段；每条路径都保留独立 `review-code`。
+
+假设分析认为应用层边界需要明确方案，因此选择**标准路径**：
 
 ```bash
 /import-issue 42           # AI 读取 Issue，创建任务，提取需求
-/analyze-task --task <task-id>    # AI 扫描代码库，定位根因，输出 analysis.md
-/review-analysis --task <task-id> # 隔离 reviewer 审查分析产物
+/analyze-task --task <task-id>    # AI 扫描代码库、记录所选路径，输出 analysis.md
 /plan-task --task <task-id>       # AI 提出修复方案
-/review-plan --task <task-id>     # fresh 隔离 reviewer 审查方案
 ```
 
 > **你审查方案后用自然语言回复：**
@@ -78,7 +86,7 @@ agent-infra 的目标就是把这层共享基础设施标准化。它为所有
 /complete-task --task <task-id>   # 任务归档
 ```
 
-**11 条命令，1 次自然语言纠正，从 Issue 到合并 PR。** 这就是完整的 SOP —— 编程也可以有标准作业流程。
+**一条由分析选择的路径、一次自然语言纠正和一次独立代码审查。** 生命周期会让证据与审查深度和任务风险相称。
 
 以上每条命令在 Claude Code、Codex、Antigravity CLI、OpenCode 中完全通用。任务进行到一半切换工具，工作流状态照常延续。每个 skill 背后做了什么，见 [内置 AI Skills](./docs/zh-CN/skills.md)。
 
@@ -192,8 +200,9 @@ ai agent-client configure
 |------|------|
 | `create-task` / `import-issue` | 从描述或 GitHub Issue 创建任务 |
 | `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
-| `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
-| `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
+| `analyze-task` | 明确范围与风险，再选择精简、标准或完整路径 |
+| `review-analysis` | 仅在完整路径需要独立需求检查点时审查分析 |
+| `plan-task` / `review-plan` | 标准和完整路径需要设计方案；只有完整路径独立审查方案 |
 | `code-task` → `review-code` | 实现并测试；`code-task` 创建本地 checkpoint，再由结构化审查检视该 checkpoint |
 | `create-pr` → `complete-task` | 将已通过审查的 checkpoint 发布到任务绑定目标分支，并在合并和最终门禁通过后归档 |
 

package/dist/bin/internal-cli.js

@@ -50,7 +50,7 @@ function taskControlTransportFailure(message, code = 'TASK_CONTROL_TRANSPORT_INV
 let controlRouted = false;
 if (!taskViewGuardFailed && !markerlessHelp && (taskControlCommand || taskWorkflowCommand || manualValidationWorkflowCommand)) {
     const transport = resolveSandboxControlTransport(process.env, {
-        localWorkflow: command === 'task-orchestration' || taskWorkflowCommand || manualValidationWorkflowCommand
+        localWorkflow: command === 'task-orchestration' || command === 'task-finalization' || taskWorkflowCommand || manualValidationWorkflowCommand
     });
     switch (transport.kind) {
         case 'fail-closed': {

package/dist/lib/internal/cli-route-inventory.js

@@ -50,7 +50,7 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
     'pr-review-grade': ['decide', 'resolve-host', 'verify-artifact'],
     'platform-checks': ['inspect', 'watch', 'resolve-run', 'logs'],
     'task-context': ['resolve'],
-    'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert'],
+    'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert', 'rework-intent-rebuild'],
     'task-warning': ['list', 'add', 'set-status'],
     'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
     'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],

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

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

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

@@ -1,6 +1,9 @@
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
-import { applyTaskFinalization } from '../task/finalization.js';
+import { applyTaskFinalization, prepareTaskFinalization } from '../task/finalization.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
+import { verifyTaskEvent } from '../task/verification.js';
+import { resolveSandboxControlTransport } from './task-operation-registry.js';
+import { requestSandboxTaskFinalization, SandboxControlClientError } from '../sandbox/control/client.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
 function envelope(status, changed, accepted, result, error) {
@@ -59,7 +62,44 @@ async function taskFinalization(args = []) {
         ...operation,
         request: { ...operation.request, taskRef: resolved.taskId }
     };
+    const transport = resolveSandboxControlTransport(process.env, { localWorkflow: true });
+    if (transport.kind === 'sandbox-local') {
+        const prepared = await prepareTaskFinalization(boundOperation.request, {
+            repoRoot,
+            preflight: (request, options) => verifyTaskEvent({ ...request, event: 'complete-task.hard-preflight' }, options)
+        });
+        if (prepared.status !== 'prepared') {
+            process.stdout.write(envelope(prepared.status, prepared.changed, true, prepared, prepared.error));
+            process.exitCode = exitCode(prepared.status);
+            return;
+        }
+        try {
+            const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
+            process.stdout.write(response.stdout);
+            process.stderr.write(response.stderr);
+            process.exitCode = response.exitCode ?? 1;
+            return;
+        }
+        catch (error) {
+            const detail = error instanceof SandboxControlClientError
+                ? error.detail
+                : { code: 'SANDBOX_CONTROL_CLIENT_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false };
+            process.stdout.write(envelope(detail.retryable ? 'blocked' : 'failed', false, false, null, detail));
+            process.exitCode = detail.retryable ? 2 : 1;
+            return;
+        }
+    }
     const result = await dispatchTaskControlOperation(createDirectHostExecutionContext({ repoRoot }), boundOperation);
+    if (result.status === 'prepared') {
+        const detail = {
+            code: 'TASK_FINALIZATION_DIRECT_COMMIT_REQUIRED',
+            message: 'direct finalization prepared external work without committing the lifecycle transition',
+            retryable: false
+        };
+        process.stdout.write(envelope('failed', result.changed, true, result, detail));
+        process.exitCode = 1;
+        return;
+    }
     process.stdout.write(envelope(result.status, result.changed, true, result, result.error));
     process.exitCode = exitCode(result.status);
 }

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

@@ -5,17 +5,18 @@ import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewSt
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, stage-status\n`;
+const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, rework-intent-rebuild, stage-status\n`;
 const FLAGS = {
     '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
     '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
     '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation',
     '--intent-id': 'intentId', '--finding-id': 'findingId', '--source-artifact': 'sourceArtifact',
-    '--source-sha256': 'sourceSha256', '--target': 'target',
+    '--source-sha256': 'sourceSha256', '--classification': 'classification',
     '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
 const BOOLEAN = new Set(['needsImplementation']);
+const REWORK_CLASSIFICATIONS = new Set(['scope-or-requirement', 'design', 'implementation', 'human-decision', 'insufficient-evidence']);
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LEDGER_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -40,6 +41,7 @@ async function taskLedger(args = []) {
         internalHandlerRoute('task-ledger', 'decision-next-id', kind),
         internalHandlerRoute('task-ledger', 'decision-upsert', kind),
         internalHandlerRoute('task-ledger', 'rework-intent-upsert', kind),
+        internalHandlerRoute('task-ledger', 'rework-intent-rebuild', kind),
         internalHandlerRoute('task-ledger', 'stage-status', kind)
     ].some(Boolean)) {
         usageFailure(`unknown ledger intent '${kind}'`);
@@ -85,14 +87,16 @@ async function taskLedger(args = []) {
         'finding-review': ['id', 'status', 'evidence'],
         'decision-next-id': [],
         'decision-upsert': ['id', 'stage', 'artifact'],
-        'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'target'],
+        'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'classification'],
+        'rework-intent-rebuild': [],
         'stage-status': ['stage']
     };
     const optional = {
         'finding-review': ['needsImplementation'],
-        'decision-upsert': ['needsImplementation']
+        'decision-upsert': ['needsImplementation'],
+        'rework-intent-rebuild': ['findingId', 'sourceArtifact', 'sourceSha256', 'classification']
     };
-    const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert'
+    const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert' || kind === 'rework-intent-rebuild'
         ? []
         : ['overrideTicket', 'overrideTarget', 'overrideScope'];
     const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...(optional[kind] ?? []), ...overrideFields]);
@@ -111,6 +115,10 @@ async function taskLedger(args = []) {
         usageFailure(dryRunConflict.message);
         return;
     }
+    if (values.classification !== undefined && !REWORK_CLASSIFICATIONS.has(String(values.classification))) {
+        usageFailure(`invalid rework classification '${values.classification}'`);
+        return;
+    }
     if (kind === 'stage-status') {
         if (!isReviewStage(String(values.stage))) {
             usageFailure(`stage-status requires a valid review stage`);

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

@@ -85,6 +85,7 @@ function internalTaskRoutes() {
         descriptor('internal', 'task-ledger', 'finding-review', 'task-bound', 'progress'),
         descriptor('internal', 'task-ledger', 'decision-upsert', 'task-bound', 'progress'),
         descriptor('internal', 'task-ledger', 'rework-intent-upsert', 'task-bound', 'progress'),
+        descriptor('internal', 'task-ledger', 'rework-intent-rebuild', 'task-bound', 'progress'),
         descriptor('internal', 'task-warning', 'list', 'task-bound', 'diagnostic'),
         descriptor('internal', 'task-warning', 'add', 'task-bound', 'progress'),
         descriptor('internal', 'task-warning', 'set-status', 'task-bound', 'progress'),

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

@@ -13,21 +13,70 @@ import { taskIssueIdentity } from './task-identities.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)]
+function referencedBackfillArtifact(taskDir, message) {
+    const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])([a-z][a-z-]*(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
         .map((match) => match[1]);
     if (names.length !== 1)
-        return null;
+        return { status: 'ignored', artifact: null, error: null };
     const parsed = parseArtifactName(names[0]);
-    if (!parsed || parsed.family !== 'pr-review')
-        return null;
+    if (!parsed || (parsed.family !== 'pr-review' && !COMPLETION_BACKFILL_FAMILIES.includes(parsed.family))) {
+        return { status: 'ignored', artifact: null, error: null };
+    }
     const artifactPath = path.join(taskDir, parsed.name);
     try {
         const stat = fs.lstatSync(artifactPath);
-        return stat.isFile() && !stat.isSymbolicLink() ? parsed.name : null;
+        if (stat.isSymbolicLink())
+            return {
+                status: 'failed', artifact: null,
+                error: { code: 'ARTIFACT_TOPOLOGY_CONFLICT', message: `SYMBOLIC_LINK: symbolic links are not workflow artifacts: ${parsed.name}`, retryable: false }
+            };
+        if (!stat.isFile())
+            return {
+                status: 'failed', artifact: null,
+                error: { code: 'ARTIFACT_TOPOLOGY_CONFLICT', message: `NON_REGULAR_FILE: artifact is not a regular file: ${parsed.name}`, retryable: false }
+            };
+        fs.accessSync(artifactPath, fs.constants.R_OK);
+        return { status: 'ready', artifact: parsed.name, error: null };
+    }
+    catch (error) {
+        return {
+            status: 'failed', artifact: null,
+            error: { code: 'ARTIFACT_READ_FAILED', message: `Unable to inspect referenced artifact '${parsed.name}': ${error instanceof Error ? error.message : String(error)}`, retryable: false }
+        };
+    }
+}
+function matchingBackfillWarnings(taskDir, content) {
+    const matches = [];
+    for (const warning of getOpenWorkflowWarnings(content)) {
+        if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact')
+            continue;
+        const reference = referencedBackfillArtifact(taskDir, warning.message);
+        if (reference.status === 'failed')
+            return { status: 'failed', matches: [], error: reference.error };
+        if (reference.status === 'ready')
+            matches.push({ warning, artifact: reference.artifact });
+    }
+    return { status: 'ready', matches, error: null };
+}
+function inspectCompletionBackfillEligibility(taskRef, options = {}) {
+    const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+    if (!resolved.ok)
+        return {
+            status: 'failed', eligible: false,
+            error: { code: resolved.code, message: resolved.message, retryable: false }
+        };
+    try {
+        const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+        const matching = matchingBackfillWarnings(resolved.taskDir, content);
+        if (matching.status === 'failed')
+            return { status: 'failed', eligible: false, error: matching.error };
+        return { status: 'ready', eligible: matching.matches.length > 0, error: null };
     }
-    catch {
-        return null;
+    catch (error) {
+        return {
+            status: 'failed', eligible: false,
+            error: { code: 'TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error), retryable: false }
+        };
     }
 }
 async function backfillCompletionComments(taskRef, options) {
@@ -46,6 +95,9 @@ async function backfillCompletionComments(taskRef, options) {
             }
         }), [], []);
     const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const matching = matchingBackfillWarnings(resolved.taskDir, initialContent);
+    if (matching.status === 'failed')
+        return result(platformResult('failed', { error: matching.error }), [], []);
     const issueIdentity = taskIssueIdentity(parseTaskFrontmatter(initialContent));
     if (!issueIdentity)
         return result(platformResult('no-op', {
@@ -79,18 +131,12 @@ async function backfillCompletionComments(taskRef, options) {
                 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) {
+    for (const { warning, artifact } of matching.matches) {
         metadata ??= captureTaskWriteMetadata();
         const resolution = [
-            `excluded=${excluded}`,
+            `artifact=${artifact}`,
             `completionFamilies=${COMPLETION_BACKFILL_FAMILIES.join(',')}`,
             `synchronized=${inventory.artifacts.map((artifact) => artifact.name).join(',') || 'none'}`,
             `completedAt=${metadata.timestamp}`
@@ -119,5 +165,5 @@ async function backfillCompletionComments(taskRef, options) {
         error: null
     }), artifacts, warnings);
 }
-export { backfillCompletionComments };
+export { backfillCompletionComments, inspectCompletionBackfillEligibility };
 //# sourceMappingURL=completion-backfill.js.map