pm-github 2026.10.24 → 2026.10.26

package/dist/closeout.js

@@ -1,5 +1,6 @@
+import { ownValue } from "./own-record.js";
 /** Close delivered tracker items using merged pull requests and head-check evidence. */
-import { close, listAllComplete, certifyCompleteListResult, PmCliError } from "@unbrained/pm-cli/sdk";
+import { close, hashDocument, locateItem, readLocatedItem, readSettings, resolveItemTypeRegistry, runWithActiveExtensions, setActiveExtensionHooks, listAllComplete, certifyCompleteListResult, getHistoryPath, readHistoryEntries, verifyHistoryEntries, PmCliError, EXIT_CODE } from "@unbrained/pm-cli/sdk";
 /** Reject non-object API payloads before reading safety-critical fields. */
 function record(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -23,9 +24,10 @@ function isoDate(value) {
 }
 /** Normalize repeatable flags without silently dropping malformed members. */
 function repeated(options, key) {
-    if (options[key] === undefined)
+    const value = ownValue(options, key);
+    if (value === undefined)
         return [];
-    const values = Array.isArray(options[key]) ? options[key] : [options[key]];
+    const values = Array.isArray(value) ? value : [value];
     if (values.length === 0 || values.some(value => typeof value !== "string" || value.trim() === ""))
         throw new Error(`--${key} requires a value.`);
     return [...new Set(values.map(value => value.trim()))];
@@ -82,23 +84,40 @@ function pullRequest(value, repo, number) {
     const raw = record(value);
     const base = record(raw.base);
     const baseRepo = record(base.repo);
-    const head = record(raw.head);
+    const head = raw.head === null || raw.head === undefined ? {} : record(raw.head);
     if (raw.number !== number || text(baseRepo.full_name).toLowerCase() !== repo.toLowerCase()
         || text(raw.html_url).toLowerCase() !== `https://github.com/${repo}/pull/${number}`.toLowerCase()
         || (raw.body !== null && typeof raw.body !== "string"))
         throw new Error("Pull-request identity or body is unverifiable.");
     return {
-        number, body: raw.body, merged: raw.merged === true,
+        number, body: raw.body, merged: typeof raw.merged === "boolean" ? raw.merged : null,
+        commits: Number.isSafeInteger(raw.commits) && Number(raw.commits) >= 0 ? Number(raw.commits) : null,
         merged_at: raw.merged_at, merge_commit_sha: raw.merge_commit_sha,
-        html_url: raw.html_url, head: { sha: text(head.sha) },
+        html_url: raw.html_url, head: { sha: typeof head.sha === "string" ? head.sha : "" },
         base: { ref: text(base.ref), repo: { full_name: baseRepo.full_name } },
     };
 }
+/** Read a validated merge time; missing or malformed chronology remains unknown. */
+function mergeTime(value) {
+    try {
+        return Date.parse(isoDate(text(value)));
+    }
+    catch {
+        return Number.NaN;
+    }
+}
+/** Name each missing merge fact without copying untrusted API values. */
+function mergeEvidenceGaps(pr) {
+    return [
+        ...(pr.merged === true ? [] : ["merged"]),
+        ...(Number.isFinite(mergeTime(pr.merged_at)) ? [] : ["merged_at"]),
+        ...(typeof pr.merge_commit_sha === "string" && /^[a-f0-9]{40}$/.test(pr.merge_commit_sha) ? [] : ["merge_commit_sha"]),
+        ...(/^[a-f0-9]{40}$/.test(pr.head.sha) ? [] : ["head.sha"]),
+    ];
+}
 /** Require complete, well-formed merge facts before any check queries or writes. */
 function mergeEvidence(pr) {
-    return pr.merged && typeof pr.merged_at === "string" && isoDate(pr.merged_at).length > 0
-        && typeof pr.merge_commit_sha === "string" && /^[a-f0-9]{40}$/.test(pr.merge_commit_sha)
-        && /^[a-f0-9]{40}$/.test(pr.head.sha);
+    return mergeEvidenceGaps(pr).length === 0;
 }
 /** Treat only permission and not-found responses as protection metadata gaps. */
 async function readProtectionSource(read) {
@@ -313,6 +332,54 @@ export function extractCloseoutItems(body) {
         return [entry];
     }).map(({ repo, item, declared }) => ({ repo, item, declared }));
 }
+/** Read the last criteria edit from immutable SDK history; unavailable chronology cannot select delivery. */
+async function acceptanceChangedAt(pmRoot, id, document) {
+    try {
+        const history = await readHistoryEntries(getHistoryPath(pmRoot, id), id);
+        if (history.length === 0 || !verifyHistoryEntries(history, document).ok)
+            return Number.NaN;
+        let changedAt = Date.parse(document.metadata.created_at);
+        for (const event of history) {
+            if (event.patch.some(patch => ["", "/metadata", "/metadata/acceptance_criteria"].includes(patch.path))) {
+                changedAt = Math.max(changedAt, Date.parse(event.ts));
+            }
+        }
+        return changedAt;
+    }
+    catch {
+        return Number.NaN;
+    }
+}
+/** Extract exact item declarations from descriptions or commit messages using the same grammar. */
+function deliveryReferences(body, repo, ids) {
+    const refs = extractCloseoutItems(body);
+    const declarations = new Set();
+    for (const match of body.matchAll(/^(?:[-*][ \t]+)?([a-z]+|pm-github:|PM item:)[ \t]+(\S+)[ \t]*$/gim)) {
+        const keyword = match[1].toLowerCase();
+        if (!CLOSING_KEYWORDS.has(keyword) && keyword !== "pm-github:" && keyword !== "pm item:")
+            continue;
+        const id = declarationKey(match[2]);
+        declarations.add(id);
+        if (/[.!]$/.test(id))
+            declarations.add(id.slice(0, -1));
+    }
+    for (const id of ids) {
+        if (declarations.has(declarationKey(id))) {
+            const ref = refs.find(ref => ref.item === id && ref.repo.toLowerCase() === repo.toLowerCase());
+            if (ref)
+                ref.declared = true;
+            else
+                refs.push({ item: id, repo, declared: true });
+        }
+    }
+    return refs;
+}
+/** Classify delivery once: only claims are candidates; unreadable claims remain unresolved. */
+function deliveryRole(declared, tagged, commitsReadable) {
+    if (declared || tagged)
+        return "candidate";
+    return commitsReadable ? "context" : "unresolved";
+}
 /** Render only the allowed GitHub facts; never include body, title or comment text. */
 function closeReason(pr, passed) {
     return JSON.stringify({ pr: pr.number, url: pr.html_url, merge_commit_sha: pr.merge_commit_sha,
@@ -357,8 +424,29 @@ export function checkEvidence(gate) {
     const successes = gate.passed.length > 0 ? `successful checks: ${gate.passed.join(", ")}` : "no check reported success";
     return `no readable required checks, so every completed head check run had to succeed, be neutral or be skipped; ${successes}`;
 }
-/** Plan all selected PRs before closing eligible items through the real SDK. */
-export async function runCloseout(pmRoot, repo, options, api) {
+/** Project one item decision onto all its candidates, including incomplete competitors. */
+function reportItemDecision(rows, decision) {
+    const candidates = rows.map(row => row.pr).sort((a, b) => a - b);
+    for (const row of rows) {
+        if (decision.kind === "chosen") {
+            if (row === decision.row)
+                continue;
+            Object.assign(row, { action: "skip", code: "duplicate_selection",
+                reason: "Another merged PR uniquely supplies the delivery evidence for this item." });
+        }
+        else {
+            Object.assign(row, { action: "needs_review", code: "needs_review", reason: decision.reason, candidates });
+            if (decision.missing.length > 0)
+                row.missing_evidence = decision.missing;
+        }
+    }
+}
+/** Plan selected PRs and apply only decisions whose exact item snapshot still matches. */
+export function runCloseout(pmRoot, repo, options, api, observer) {
+    return closeoutAttempt(pmRoot, repo, options, api, true, observer);
+}
+/** Re-select a conflicted item once; each attempt installs a lock-scoped SDK precondition. */
+async function closeoutAttempt(pmRoot, repo, options, api, retry, observer, onlyItem) {
     if (!repo || !/^(?!\.{1,2}\/)[A-Za-z0-9_.-]+\/(?!\.{1,2}$)[A-Za-z0-9_.-]+$/.test(repo))
         throw new CloseoutUsageError("closeout requires --repo owner/repo or PM_GITHUB_REPO.");
     const numbers = usage(() => repeated(options, "pr")).map(value => {
@@ -369,9 +457,9 @@ export async function runCloseout(pmRoot, repo, options, api) {
     const since = options.since === undefined ? undefined : usage(() => isoDate(text(options.since)));
     if ((numbers.length === 0) === (since === undefined))
         throw new CloseoutUsageError("Select either repeatable --pr <n> or --since <ISO date>.");
-    const declared = usage(() => requiredContexts(options["required-checks"] ?? options.requiredChecks));
+    const declared = usage(() => requiredContexts(ownValue(options, "required-checks") ?? options.requiredChecks));
     const skip = new Set(usage(() => repeated(options, "skip")));
-    const apply = options.apply === true && options["dry-run"] !== true && options.dryRun !== true;
+    const apply = options.apply === true && ownValue(options, "dry-run") !== true && options.dryRun !== true;
     if (since !== undefined) {
         // Rows arrive newest-updated first and a merge never postdates its PR's update, so a row updated
         // before the cutoff proves no later row can have merged at or after it.
@@ -379,7 +467,8 @@ export async function runCloseout(pmRoot, repo, options, api) {
         const older = (row) => typeof row === "object" && row !== null && Date.parse(String(row.updated_at)) < cutoff;
         for (const value of await pages(api, `/repos/${repo}/pulls?state=closed&sort=updated&direction=desc&per_page=100`, false, older)) {
             const pr = record(value);
-            if (pr.merged_at !== null && Date.parse(isoDate(text(pr.merged_at))) >= Date.parse(since)) {
+            // A missing or malformed merge time is uncertainty, never proof of an unmerged PR.
+            if (!Number.isFinite(mergeTime(pr.merged_at)) || mergeTime(pr.merged_at) >= cutoff) {
                 if (!Number.isSafeInteger(pr.number) || Number(pr.number) < 1)
                     throw new Error("Invalid selected pull-request number.");
                 numbers.push(Number(pr.number));
@@ -387,10 +476,26 @@ export async function runCloseout(pmRoot, repo, options, api) {
         }
     }
     const corpus = certifyCompleteListResult(await listAllComplete({}, { pmRoot, noExtensions: true }));
+    await observer?.("listed");
+    const settings = await readSettings(pmRoot);
+    const types = resolveItemTypeRegistry(settings).type_to_folder;
+    const snapshots = new Map();
+    const documents = new Map();
     const items = new Map(corpus.items.map(item => [item.id, item]));
+    // Selection and its guard must use the same authoritative document, including collections and body.
+    for (const id of items.keys()) {
+        const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, types);
+        if (!located)
+            throw new Error("Closeout item snapshot unavailable.");
+        const { document } = await readLocatedItem(located, { schema: settings.schema });
+        snapshots.set(id, hashDocument(document));
+        documents.set(id, document);
+        items.set(id, document.metadata);
+    }
+    await observer?.("snapshot");
     // Containers close when their children are done, never because a pull request mentions them.
     const activeChildren = new Map();
-    for (const item of corpus.items) {
+    for (const item of items.values()) {
         const parent = item.parent;
         if (typeof parent === "string" && !TERMINAL_STATUSES.includes(item.status))
             activeChildren.set(parent, (activeChildren.get(parent) ?? 0) + 1);
@@ -398,35 +503,51 @@ export async function runCloseout(pmRoot, repo, options, api) {
     const plan = [];
     const checks = [];
     const closures = [];
+    const candidates = new Map();
+    const unreadable = [];
     for (const number of [...new Set(numbers)].sort((a, b) => a - b)) {
-        const pr = pullRequest(await payload(api, `/repos/${repo}/pulls/${number}`), repo, number);
-        let gate = { pr: number, code: "incomplete_merge", rule: "unavailable", ok: false, passed: [], reason: "Pull request is not merged or merge evidence is incomplete." };
+        let evidence;
+        try {
+            evidence = await payload(api, `/repos/${repo}/pulls/${number}`);
+        }
+        catch {
+            unreadable.push(number);
+            continue;
+        }
+        const pr = pullRequest(evidence, repo, number);
+        let gate = { pr: number, code: "incomplete_merge", rule: "unavailable", ok: false, passed: [], reason: `Missing or invalid merge evidence: ${mergeEvidenceGaps(pr).join(", ")}.` };
         if (mergeEvidence(pr))
             gate = await checkCloseoutHead(api, repo, pr, declared);
         checks.push(gate);
-        const refs = extractCloseoutItems(pr.body ?? "");
-        // Scan declarations once per PR, retaining case-insensitive IDs and optional punctuation.
-        const declarations = new Set();
-        for (const match of (pr.body ?? "").matchAll(/^(?:[-*][ \t]+)?([a-z]+|pm-github:|PM item:)[ \t]+(\S+)[ \t]*$/gim)) {
-            const keyword = match[1].toLowerCase();
-            if (!CLOSING_KEYWORDS.has(keyword) && keyword !== "pm-github:" && keyword !== "pm item:")
-                continue;
-            const id = declarationKey(match[2]);
-            declarations.add(id);
-            if (/[.!]$/.test(id))
-                declarations.add(id.slice(0, -1));
+        const refs = deliveryReferences(pr.body ?? "", repo, items.keys());
+        // Commit messages can independently claim delivery. Missing commit evidence never upgrades a mention.
+        let messages = [];
+        let commitsReadable = false;
+        try {
+            if (pr.merged !== false) {
+                const commits = await pages(api, `/repos/${repo}/pulls/${number}/commits?per_page=100`);
+                if (pr.commits === null || commits.length !== pr.commits)
+                    throw new Error("Incomplete commit evidence.");
+                messages = commits.map(value => text(record(record(value).commit).message));
+                commitsReadable = true;
+            }
+        }
+        catch { /* Retain description references; unresolved commit evidence is held during attribution. */ }
+        for (const ref of deliveryReferences(messages.join("\n"), repo, items.keys())) {
+            const existing = refs.find(entry => entry.item === ref.item && entry.repo.toLowerCase() === ref.repo.toLowerCase());
+            if (existing)
+                existing.declared ||= ref.declared;
+            else
+                refs.push(ref);
         }
+        // An unreadable commit set cannot prove that an item has no commit-only delivery link.
         for (const item of items.values()) {
-            // Delivery must be declared in this PR body, never inferred from tracker metadata.
-            if (declarations.has(declarationKey(item.id))) {
-                const ref = refs.find(ref => ref.item === item.id && ref.repo.toLowerCase() === repo.toLowerCase());
-                if (ref)
-                    ref.declared = true;
-                else
-                    refs.push({ item: item.id, repo, declared: true });
+            if ((item.tags.includes(`delivery-pr:${pr.html_url}`) || (!commitsReadable && pr.merged !== false)) && !refs.some(ref => ref.item === item.id && ref.repo.toLowerCase() === repo.toLowerCase())) {
+                refs.push({ item: item.id, repo, declared: false });
             }
         }
         for (const ref of refs) {
+            const role = deliveryRole(ref.declared, items.get(ref.item)?.tags.includes(`delivery-pr:${pr.html_url}`) === true, commitsReadable);
             let reason;
             let code;
             if (ref.repo.toLowerCase() !== repo.toLowerCase()) {
@@ -445,9 +566,9 @@ export async function runCloseout(pmRoot, repo, options, api) {
                 code = "already_terminal";
                 reason = "Item is already closed or canceled.";
             }
-            else if (!gate.ok) {
-                code = gate.code;
-                reason = gate.reason;
+            else if (pr.merged === false) {
+                code = "not_merged";
+                reason = "Pull request is confirmed unmerged and cannot deliver this item.";
             }
             else if (items.get(ref.item).type === "Epic") {
                 code = "epic";
@@ -457,9 +578,17 @@ export async function runCloseout(pmRoot, repo, options, api) {
                 code = "active_children";
                 reason = `Item has ${activeChildren.get(ref.item)} non-terminal child item(s).`;
             }
-            else if (!ref.declared) {
+            else if (role === "context") {
                 code = "not_delivery";
-                reason = "Mentioned, not delivered. A mention is not delivery. Declare Closes, Fixes, Resolves or Delivers, or use a structured PM item: or pm-github: declaration.";
+                reason = "Mentioned, not delivered. A mention is not delivery. This fully inspected PR has no delivery claim and is context only.";
+            }
+            else if (!gate.ok) {
+                code = gate.code;
+                reason = gate.reason;
+            }
+            else if (role === "unresolved") {
+                code = "head_evidence_unavailable";
+                reason = "Commit delivery evidence unavailable or incomplete.";
             }
             else {
                 reason = gate.reason;
@@ -472,60 +601,157 @@ export async function runCloseout(pmRoot, repo, options, api) {
                     actualResult: `Merged at ${pr.merged_at}; ${checkEvidence(gate)}`,
                 });
                 plan.push(row);
+                const group = candidates.get(ref.item) ?? [];
+                group.push({ row, pr, declared: ref.declared, commitsReadable });
+                candidates.set(ref.item, group);
                 continue;
             }
-            plan.push({ item: ref.item, pr: number, action: "skip", code, reason });
+            const row = { item: ref.item, pr: number, action: "skip", code, reason };
+            plan.push(row);
+            if (role !== "context" && pr.merged !== false && items.has(ref.item) && ref.repo.toLowerCase() === repo.toLowerCase()
+                && !skip.has(ref.item) && !TERMINAL_STATUSES.includes(items.get(ref.item).status)
+                && items.get(ref.item).type !== "Epic" && !activeChildren.has(ref.item)) {
+                const group = candidates.get(ref.item) ?? [];
+                group.push({ row, pr, declared: ref.declared, commitsReadable });
+                candidates.set(ref.item, group);
+            }
         }
     }
-    // Choose one complete, passing delivery before any SDK write. Merge chronology, not PR number,
-    // determines the winner; an equal timestamp uses the higher PR number for stable selection.
-    const deliveries = new Map();
-    for (const entry of closures) {
-        const previous = deliveries.get(entry.row.item);
-        if (!previous || Date.parse(entry.at) >= Date.parse(previous.at)) {
-            deliveries.set(entry.row.item, entry);
+    // A failed PR read can hide linkage and a competing claim. Retain its number for
+    // every active eligible item; without the PR evidence no item can be proved unrelated.
+    for (const number of unreadable) {
+        const url = `https://github.com/${repo}/pull/${number}`;
+        for (const item of items.values()) {
+            if (skip.has(item.id) || TERMINAL_STATUSES.includes(item.status) || item.type === "Epic" || activeChildren.has(item.id))
+                continue;
+            const row = { item: item.id, pr: number, action: "skip", code: "head_evidence_unavailable", reason: "Pull-request fetch failed; merge, linkage and delivery evidence unavailable." };
+            plan.push(row);
+            const group = candidates.get(item.id) ?? [];
+            group.push({ row, pr: { number, html_url: url, body: null, merged: true, merged_at: null, merge_commit_sha: null, commits: null,
+                    head: { sha: "" }, base: { ref: "", repo: { full_name: repo } } }, declared: false, commitsReadable: false });
+            candidates.set(item.id, group);
         }
     }
-    for (const entry of closures) {
-        if (deliveries.get(entry.row.item) !== entry) {
-            entry.row.action = "skip";
-            entry.row.code = "duplicate_selection";
-            entry.row.reason = "A later qualifying merged PR declares delivery for this item.";
+    // Resolve attribution before any SDK mutation; passing checks never break a delivery tie.
+    for (const [id, group] of candidates) {
+        const item = items.get(id);
+        const explicit = item.tags.filter(tag => tag.startsWith("delivery-pr:"));
+        const cutoff = await acceptanceChangedAt(pmRoot, id, documents.get(id));
+        await observer?.("history");
+        const plausible = group.filter(entry => !Number.isFinite(mergeTime(entry.pr.merged_at)) || mergeTime(entry.pr.merged_at) > cutoff);
+        const eligible = explicit.length > 0
+            ? group.filter(entry => explicit.length === 1 && explicit[0] === `delivery-pr:${entry.pr.html_url}`)
+            : plausible.filter(entry => entry.declared);
+        const uncertain = explicit.length === 1 && eligible.length === 1 ? eligible : plausible;
+        const missing = uncertain.flatMap(entry => {
+            const gaps = ["incomplete_merge", "head_evidence_unavailable", "required_checks_unverified", "head_checks_failed"].includes(entry.row.code)
+                ? [{ pr: entry.pr.number, code: entry.row.code, reason: entry.row.reason }] : [];
+            if (!entry.commitsReadable)
+                gaps.push({ pr: entry.pr.number, code: "head_evidence_unavailable", reason: "Commit delivery evidence unavailable or incomplete." });
+            return gaps;
+        });
+        // One item decision owns every candidate status. Evidence codes describe PR facts,
+        // but an unchosen PR cannot remain a fatal refusal after another PR wins.
+        const chosen = eligible.length === 1 && missing.length === 0 ? eligible[0].row : undefined;
+        if (chosen)
+            reportItemDecision(group.map(entry => entry.row), { kind: "chosen", row: chosen });
+        else if (group.length > 1 || explicit.length > 0 || missing.length > 0 || group[0].row.code !== "not_delivery") {
+            reportItemDecision(group.map(entry => entry.row), { kind: "blocking_hold",
+                reason: "Delivery attribution or chosen PR evidence is unresolved; set one delivery-pr:<canonical PR URL> tag or verify a unique delivery claim after the last acceptance-criteria change."
+                    + missing.map(gap => ` PR #${gap.pr}: ${gap.reason}`).join(""), missing });
         }
     }
+    await observer?.("selection");
     let closed = 0;
     let failed = 0;
+    const handled = new Set();
+    const dependentConflicts = new Map();
+    /** Replace stale decisions with one fresh selection, retaining a reason when linkage disappeared. */
+    async function reselect(id, pr) {
+        handled.add(id);
+        const fresh = await closeoutAttempt(pmRoot, repo, options, api, false, observer, id);
+        checks.splice(0, checks.length, ...fresh.checks);
+        const replacement = fresh.plan;
+        if (!replacement.some(row => row.item === id))
+            replacement.push({ item: id, pr, action: "needs_review", code: "needs_review",
+                candidates: [pr], reason: "Item revision changed; fresh selection found no delivery evidence. Hold for review." });
+        const replaced = new Set(replacement.map(row => row.item));
+        const retained = plan.filter(row => !replaced.has(row.item));
+        plan.splice(0, plan.length, ...retained, ...replacement);
+        closed += fresh.closed;
+        failed += fresh.failed;
+    }
     if (apply) {
         for (const entry of closures) {
-            if (entry.row.action !== "close")
+            if (entry.row.action !== "close" || (onlyItem !== undefined && entry.row.item !== onlyItem))
                 continue;
             try {
-                await close(entry.row.item, entry.reason, { author: "pm-github", completedAt: entry.at,
-                    resolution: entry.resolution, expectedResult: entry.expectedResult, actualResult: entry.actualResult,
-                }, { pmRoot, noExtensions: true });
+                await observer?.("before_close");
+                // The pinned SDK has no public close(expectedRevision). Its transactional hook runs
+                // inside the same per-item lock as lifecycle validation, persistence and history.
+                await runWithActiveExtensions({ path: pmRoot, noExtensions: true }, async () => {
+                    setActiveExtensionHooks({ beforeCommand: [], afterCommand: [], onRead: [], onWrite: [], onIndex: [],
+                        beforeMutation: [{ layer: "project", name: "closeout-revision", run: async (context) => {
+                                    await observer?.("locked");
+                                    // SDK close may also auto-unblock dependents. Every resulting write needs its own snapshot.
+                                    const before = context.before;
+                                    const id = before.metadata.id;
+                                    if (hashDocument(before) !== snapshots.get(id)) {
+                                        if (id !== entry.row.item)
+                                            dependentConflicts.set(id, entry.row.pr);
+                                        throw new PmCliError("Closeout item revision changed.", 1, { code: "closeout_revision_changed" });
+                                    }
+                                } }],
+                    });
+                    await close(entry.row.item, entry.reason, { author: "pm-github", completedAt: entry.at,
+                        resolution: entry.resolution, expectedResult: entry.expectedResult, actualResult: entry.actualResult,
+                    }, { pmRoot, noExtensions: true });
+                });
                 closed++;
+                handled.add(entry.row.item);
             }
             catch (error) {
+                if (error instanceof PmCliError && (error.code === "closeout_revision_changed"
+                    || (error.code === undefined && error.exitCode === EXIT_CODE.CONFLICT))) {
+                    if (retry) {
+                        await reselect(entry.row.item, entry.row.pr);
+                        continue;
+                    }
+                    reportItemDecision(plan.filter(row => row.item === entry.row.item && row.code !== "not_delivery"), { kind: "blocking_hold",
+                        reason: "Item revision changed again after one delivery re-selection; hold for review.", missing: [] });
+                    continue;
+                }
                 failed++;
-                entry.row.action = "skip";
-                entry.row.code = "close_failed";
-                entry.row.reason = closeoutFailureReason(error);
+                const reason = closeoutFailureReason(error);
+                reportItemDecision(plan.filter(row => row.item === entry.row.item && row.code !== "not_delivery"), { kind: "blocking_hold", reason,
+                    missing: [{ pr: entry.row.pr, code: "close_failed", reason }] });
             }
         }
+        for (const [id, pr] of dependentConflicts) {
+            if (handled.has(id))
+                continue;
+            if (retry)
+                await reselect(id, pr);
+            else
+                plan.push({ item: id, pr, action: "needs_review", code: "needs_review", candidates: [pr],
+                    reason: "Dependent item revision changed during re-selection; automatic unblock held for review." });
+        }
     }
-    return { command: "github closeout", repo, dry_run: !apply, plan, checks, closed, failed };
+    return { command: "github closeout", repo, dry_run: !apply,
+        plan: onlyItem === undefined ? plan : plan.filter(row => row.item === onlyItem || dependentConflicts.has(row.item)), checks, closed, failed };
 }
 /** Keep actionable decisions and their checks while counting routine skips by stable code. */
 export function compactCloseoutReport(report) {
-    const skipped = {};
+    const skipped = new Map();
     const plan = report.plan.flatMap(row => {
-        if (["already_terminal", "other_repository", "duplicate_selection", "explicit_skip"].includes(row.code)) {
-            skipped[row.code] = (skipped[row.code] ?? 0) + 1;
+        if (["already_terminal", "other_repository", "duplicate_selection", "explicit_skip", "not_merged"].includes(row.code)) {
+            skipped.set(row.code, (skipped.get(row.code) ?? 0) + 1);
             return [];
         }
-        return [{ ...row, action: row.action === "close" ? "close" : "refuse" }];
+        return [{ ...row, action: row.action === "skip" && row.code !== "not_delivery" ? "refuse" : row.action }];
     });
     const prs = new Set(plan.map(row => row.pr));
-    return { ...report, plan, skipped, checks: report.checks.filter(gate => prs.has(gate.pr)) };
+    const counts = Object.fromEntries(skipped);
+    return { ...report, plan, skipped: counts, checks: report.checks.filter(gate => prs.has(gate.pr)) };
 }
 //# sourceMappingURL=closeout.js.map