comfyui-mcp 0.52.46 → 0.52.47

package/dist/orchestrator/edit-node-uncollapse.js

@@ -0,0 +1,87 @@
+/**
+ * #2004 — panel_edit_node(collapsed:false) can reject a collapsed node's own
+ * stored height 0 ("size must be two positive numbers within a reasonable
+ * canvas range"). LiteGraph serializes a title-chip as size[1]===0; the panel
+ * then validates that stored pair when expanding if a size is supplied, and
+ * the verified workaround is to pass an explicit positive size.
+ *
+ * These helpers restore a usable [width, height] from the live query BEFORE
+ * graph_edit_node, so the caller does not have to re-supply geometry they
+ * never asked to change. Fail-open: an unreadable probe leaves the original
+ * command untouched.
+ *
+ * Fallback extents match create-group-membership / the panel's finiteExtent
+ * defaults (DEFAULT_NODE_WIDTH / DEFAULT_NODE_BODY_HEIGHT). full_height on a
+ * collapsed node is the 30px chip, not the pre-collapse body — do not use it.
+ */
+import { DEFAULT_NODE_BODY_HEIGHT, DEFAULT_NODE_WIDTH, parseDetailNodesFromQueryText, } from "./create-group-membership.js";
+export function pairSize(size) {
+    if (!Array.isArray(size) || size.length < 2)
+        return null;
+    const w = Number(size[0]);
+    const h = Number(size[1]);
+    return Number.isFinite(w) && Number.isFinite(h) ? [w, h] : null;
+}
+/** True when the stored pair would fail the panel's sizeSane (both > 0). */
+export function needsUncollapseSizeRestore(size) {
+    const p = pairSize(size);
+    return !p || !(p[0] > 0 && p[1] > 0);
+}
+export function restoredUncollapseSize(size) {
+    const p = pairSize(size);
+    const w = p && p[0] > 0 ? p[0] : DEFAULT_NODE_WIDTH;
+    const h = p && p[1] > 0 ? p[1] : DEFAULT_NODE_BODY_HEIGHT;
+    return [w, h];
+}
+function parseToolJson(res) {
+    if (!res || res.isError)
+        return null;
+    const text = res.content.find((c) => c.type === "text")?.text;
+    if (typeof text !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * When uncollapsing a SINGLE node without an explicit size, query the live
+ * geometry and restore a positive size if the stored height is 0 (or otherwise
+ * not sizeSane). Bulk node_ids keep one shared size, so they are left alone.
+ * Never throws.
+ */
+export async function sizeForUncollapse(args, call) {
+    if (args.collapsed !== false)
+        return undefined;
+    if (args.size !== undefined)
+        return undefined;
+    if (args.node_ids !== undefined)
+        return undefined;
+    if (args.node_id === undefined)
+        return undefined;
+    try {
+        const query = await call({
+            cmd: "graph_query",
+            ids: [args.node_id],
+            fields: "detail",
+            limit: 1,
+        }, 8000);
+        if (query.isError)
+            return undefined;
+        const nodes = parseDetailNodesFromQueryText(parseToolJson(query)?.text);
+        const wanted = String(args.node_id);
+        const node = nodes.find((n) => String(n.id) === wanted) ?? nodes[0];
+        if (!node || !needsUncollapseSizeRestore(node.size))
+            return undefined;
+        return restoredUncollapseSize(node.size);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=edit-node-uncollapse.js.map

package/dist/orchestrator/edit-node-uncollapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-node-uncollapse.js","sourceRoot":"","sources":["../../src/orchestrator/edit-node-uncollapse.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator/get-errors-audit.js

@@ -0,0 +1,569 @@
+/**
+ * #1973 — panel_get_errors must not present a clean `errored_count: 0` while
+ * its live combo scan still has nodes unchecked.
+ *
+ * The panel's graph_get_errors shares one elective server-call budget and
+ * gives the live combo scan only a 4 s STEP cap (GET_ERRORS_STEP_CAP_MS), so a
+ * ~77-node graph routinely returns `unchecked_budget_exhausted: true` with the
+ * sampler / decoder / assembler / SaveVideo still in `unchecked_nodes`, plus
+ * the clean-scan note. The orchestrator already waits 30 s for that reply, so
+ * after a budget-exhausted payload it finishes the leftover nodes from ONE
+ * batched `graph_get_object_info` plus a targeted `graph_query` — not another
+ * per-class round trip. If that completion cannot run, the reply still leads
+ * with `audit_complete: false` and checked/unchecked counts rather than a
+ * primary clean 0.
+ *
+ * TWO RULES THIS MODULE IS BUILT AROUND, both learned the expensive way:
+ *
+ * 1. ANY abstention makes the audit incomplete, not just a budget one. The
+ *    panel abstains for five different reasons (live-combo-availability.js) and
+ *    only two of them raise `unchecked_budget_exhausted`. The asset-probe cap,
+ *    a failed /object_info lookup and an unanswered file check produce the
+ *    SAME misread this issue reports — `errored_count: 0` first, "no errors
+ *    recorded" attached — so completeness is judged from the abstention LIST,
+ *    never from the budget flag alone.
+ *
+ * 2. This pass may retire an abstention; it may never manufacture a verdict the
+ *    panel's own scanner would have refused to give. It has no /view probe, so
+ *    on an UPLOAD input — the one option list ComfyUI structurally cannot
+ *    enumerate (#1357/#387) — non-membership is not evidence of absence and the
+ *    node stays unchecked. The upload-flag list here is ComfyUI's own
+ *    (comfy_api/latest/_io.py `UploadType`), which is WIDER than the panel's:
+ *    `UploadType.model` serialises as `file_upload`, and abstaining on a flag
+ *    the panel misses is the fail-closed direction.
+ */
+import { LIMIT_CEILING, MAX_CHARS_CEILING } from "../services/graph-query.js";
+/**
+ * The abstentions that a second, batched read can actually retire: the two the
+ * panel raises when it runs out of the shared budget or its per-call class cap.
+ * Everything else it abstains for (a failed lookup, an unanswered file probe,
+ * the probe cap) is NOT retried here — but it still counts as an incomplete
+ * audit. See `isGetErrorsAuditIncomplete`.
+ */
+const RETRYABLE_UNCHECKED_RE = /ran out of its shared server-call budget|lookup cap was reached/i;
+const FILE_LIKE = /\.[A-Za-z0-9_]{2,12}$/;
+/**
+ * ComfyUI's own upload-input flags, from `UploadType` in
+ * comfy_api/latest/_io.py — image/audio/video plus `file_upload`, which is what
+ * `UploadType.model` (Load3D, Load3DAnimation) serialises to. The panel's list
+ * omits `file_upload`; matching ComfyUI rather than the panel is deliberate,
+ * because every flag added here only ever makes this pass ABSTAIN more.
+ * `model_upload` is kept for panels/packs that spell it that way.
+ */
+const UPLOAD_CONFIG_FLAGS = [
+    "image_upload",
+    "video_upload",
+    "audio_upload",
+    "model_upload",
+    "file_upload",
+];
+export function parseToolResultJson(res) {
+    if (!res || res.isError)
+        return null;
+    const entry = res.content?.find((c) => c.type === "text");
+    const text = entry && entry.type === "text" ? entry.text : undefined;
+    if (typeof text !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function asUncheckedList(payload) {
+    return Array.isArray(payload.unchecked_nodes)
+        ? payload.unchecked_nodes
+        : [];
+}
+/** An abstention a second batched read has a chance of retiring. */
+function isRetryableUnchecked(entry) {
+    return typeof entry?.reason === "string" && RETRYABLE_UNCHECKED_RE.test(entry.reason);
+}
+/** Distinct node ids the scan abstained on — same counting rule as the panel. */
+export function uncheckedNodeCount(unchecked) {
+    return new Set(unchecked.map((u, i) => (u?.id == null ? `#${i}` : `id:${String(u.id)}`))).size;
+}
+/**
+ * Judged from the abstention LIST, not from the budget flag.
+ *
+ * `unchecked_budget_exhausted` covers only two of the panel's five abstention
+ * reasons. A scan stopped by the file-probe cap emits `unchecked_nodes` and
+ * `unchecked_asset_probe_limit` with NO budget flag, and the panel's own `clean`
+ * predicate does not consider abstentions at all — so that payload ships
+ * `errored_count: 0` plus "no errors recorded" next to a list of nodes nobody
+ * judged. That is the reported misread with a different cause, and the reporter
+ * asked for the completeness header "when ANY nodes are unchecked".
+ */
+export function isGetErrorsAuditIncomplete(payload) {
+    if (payload.unchecked_budget_exhausted === true)
+        return true;
+    if (payload.unchecked_class_limit != null)
+        return true;
+    if (payload.unchecked_asset_probe_limit != null)
+        return true;
+    return asUncheckedList(payload).length > 0;
+}
+/**
+ * The option list for an input spec, in either schema form, or null when this
+ * pass has no authority over it.
+ *
+ * ComfyUI serialises a V1 combo as `[[...allowed], {cfg}]` and a V3 one as
+ * `["COMBO", {options: [...], ...}]` (`add_to_dict_v1` writes
+ * `(io_type, as_dict())`). Both are read here. A MULTISELECT combo is refused:
+ * its stored value is a selection of several options, so membership in the list
+ * is the wrong question and asking it reports every such widget as invalid.
+ */
+function comboOptions(spec) {
+    if (!Array.isArray(spec) || spec.length === 0)
+        return null;
+    const cfg = spec[1] && typeof spec[1] === "object" && !Array.isArray(spec[1])
+        ? spec[1]
+        : null;
+    if (cfg?.multiselect)
+        return null;
+    const type = spec[0];
+    if (Array.isArray(type))
+        return type.filter((v) => typeof v === "string");
+    if (typeof type !== "string" || !/COMBO/i.test(type) || /DYNAMIC/i.test(type))
+        return null;
+    const opts = cfg?.options;
+    if (!Array.isArray(opts))
+        return null;
+    const strings = opts.filter((v) => typeof v === "string");
+    return strings.length === opts.length ? strings : null;
+}
+/**
+ * An UPLOAD input, whose valid values live on DISK and not only in the combo
+ * snapshot. Any truthy flag counts — the panel reads these the same way
+ * (`UPLOAD_CONFIG_FLAGS.some((f) => config[f])`), and a pack that writes `1`
+ * rather than `true` must not fall through to a hard verdict.
+ */
+function isUploadCombo(spec) {
+    if (!Array.isArray(spec))
+        return false;
+    const cfg = spec[1];
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg))
+        return false;
+    const c = cfg;
+    return UPLOAD_CONFIG_FLAGS.some((f) => !!c[f]);
+}
+function optionsLookLikeFiles(options) {
+    if (options.length === 0)
+        return false;
+    return options.filter((s) => FILE_LIKE.test(s)).length * 2 >= options.length;
+}
+function rewriteTextPayload(res, payload) {
+    const idx = res.content.findIndex((c) => c.type === "text");
+    if (idx < 0)
+        return res;
+    return {
+        ...res,
+        content: res.content.map((c, i) => i === idx && c.type === "text" ? { ...c, text: JSON.stringify(payload, null, 2) } : c),
+    };
+}
+function parseQueryNodes(query) {
+    const out = [];
+    const take = (raw) => {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return;
+        const n = raw;
+        if (n.id == null)
+            return;
+        const type = typeof n.type === "string" ? n.type : typeof n.class_type === "string" ? n.class_type : "";
+        const widgets = n.widgets && typeof n.widgets === "object" && !Array.isArray(n.widgets)
+            ? n.widgets
+            : {};
+        const linkedInputs = new Set();
+        if (Array.isArray(n.inputs)) {
+            for (const rawInput of n.inputs) {
+                if (!rawInput || typeof rawInput !== "object" || Array.isArray(rawInput))
+                    continue;
+                const input = rawInput;
+                if (typeof input.name !== "string")
+                    continue;
+                if (input.link != null || input.connected_from != null)
+                    linkedInputs.add(input.name);
+            }
+        }
+        if (n.driven_by_link && typeof n.driven_by_link === "object" && !Array.isArray(n.driven_by_link)) {
+            for (const name of Object.keys(n.driven_by_link))
+                linkedInputs.add(name);
+        }
+        out.push({ id: n.id, type, widgets, linkedInputs });
+    };
+    if (Array.isArray(query.nodes))
+        for (const n of query.nodes)
+            take(n);
+    if (typeof query.text === "string") {
+        for (const line of query.text.split("\n")) {
+            const t = line.trim();
+            if (!t.startsWith("{"))
+                continue;
+            try {
+                take(JSON.parse(t));
+            }
+            catch {
+                /* a compact/ids line is not a detail row */
+            }
+        }
+    }
+    return out;
+}
+function objectInfoFromReply(reply) {
+    const info = reply.object_info;
+    if (info && typeof info === "object" && !Array.isArray(info) && Object.keys(info).length > 0) {
+        return info;
+    }
+    // A panel that returns the map at the top level (no wrapper) is still a schema.
+    const looksLikeDef = (v) => !!v && typeof v === "object" && !Array.isArray(v) && ("input" in v || "output" in v);
+    if (Object.values(reply).some(looksLikeDef) && !("cmd" in reply)) {
+        return reply;
+    }
+    return null;
+}
+function inputSpecsOf(def) {
+    if (!def || typeof def !== "object" || Array.isArray(def))
+        return {};
+    const input = def.input;
+    if (!input || typeof input !== "object")
+        return {};
+    return {
+        ...(input.required && typeof input.required === "object" && !Array.isArray(input.required)
+            ? input.required
+            : {}),
+        ...(input.optional && typeof input.optional === "object" && !Array.isArray(input.optional)
+            ? input.optional
+            : {}),
+    };
+}
+function judgeLeftoverCombos(leftover, nodes, objectInfo) {
+    const byId = new Map(nodes.map((n) => [String(n.id), n]));
+    const unavailable = [];
+    const stillUnchecked = [];
+    // One pass per leftover NODE: a budget skip is a node-level abstention, and
+    // judging its combos from the batched schema retires that skip.
+    const leftoverById = new Map();
+    for (const entry of leftover) {
+        if (entry?.id == null) {
+            stillUnchecked.push(entry);
+            continue;
+        }
+        leftoverById.set(String(entry.id), entry);
+    }
+    for (const [id, entry] of leftoverById) {
+        const node = byId.get(id);
+        const className = node?.type || (typeof entry.type === "string" ? entry.type : "");
+        if (!node || !className) {
+            stillUnchecked.push(entry);
+            continue;
+        }
+        // Own properties only. `objectInfo[className]` walks the prototype, so a
+        // leftover type named `toString` (or `constructor`, `valueOf`, …) against
+        // any ordinary non-empty /object_info map would resolve to a Function,
+        // look "found", yield no combo specs, and retire the node — audit_complete
+        // with unchecked_count:0 for a class that is not in the schema at all.
+        const def = Object.hasOwn(objectInfo, className) ? objectInfo[className] : undefined;
+        if (!def) {
+            stillUnchecked.push({
+                id: node.id,
+                type: className,
+                reason: "node type not found in /object_info",
+            });
+            continue;
+        }
+        const specs = inputSpecsOf(def);
+        const comboNames = Object.entries(specs)
+            .filter(([, spec]) => comboOptions(spec) !== null)
+            .map(([name]) => name);
+        // A linked combo is driven by its upstream value, not by the stored widget
+        // value. This completion pass has no execution-value probe, so it must not
+        // judge the stale/absent stored value as if it were live.
+        const linkedCombos = comboNames.filter((name) => node.linkedInputs.has(name));
+        if (linkedCombos.length > 0) {
+            stillUnchecked.push({
+                ...entry,
+                reason: `not checked: combo widget(s) ${linkedCombos.join(", ")} are driven by a live link`,
+            });
+            continue;
+        }
+        // A def with a combo input whose widget value is absent is an unread node,
+        // even when another non-combo widget (for example seed) is present. The old
+        // empty-map check retired { widgets: { seed: 1 }, linked checkpoint }.
+        const unreadCombos = comboNames.filter((name) => !Object.hasOwn(node.widgets, name));
+        if (unreadCombos.length > 0) {
+            stillUnchecked.push(entry);
+            continue;
+        }
+        for (const [name, value] of Object.entries(node.widgets)) {
+            const spec = specs[name];
+            const options = comboOptions(spec);
+            if (!options)
+                continue;
+            if (typeof value !== "string" || value === "")
+                continue;
+            // Upload inputs can accept a freshly uploaded root-level filename that
+            // never appears in /object_info's enumerated options. This pass has no
+            // /view probe, so every non-member on an upload combo is uncheckable —
+            // not a missing asset verdict.
+            if (isUploadCombo(spec) && !options.includes(value)) {
+                stillUnchecked.push({
+                    id: node.id,
+                    type: className,
+                    widget: name,
+                    value,
+                    reason: "not checked: this value names a file below the input root (or under an [output]/[temp]/[input] annotation), which /object_info's combo list cannot enumerate",
+                });
+                continue;
+            }
+            if (options.includes(value))
+                continue;
+            unavailable.push({
+                id: node.id,
+                type: className,
+                widget: name,
+                value,
+                option_count: options.length,
+                kind: options.length === 0 || optionsLookLikeFiles(options) ? "missing_asset" : "invalid_value",
+                // WHO JUDGED THIS. Until #1973 every entry in unavailable_widget_values came
+                // from the panel's own scanner, so the field name carried an implied
+                // provenance. Appending here silently invalidates that: this pass reads the
+                // V3 `["COMBO", {...}]` form the panel's parseClassCombos structurally cannot
+                // see, and it has no /view probe to fall back on. Merging an unvetted verdict
+                // into a vetted list under the same field is the attribution defect — a reader
+                // that cannot tell which scanner spoke cannot weigh the answer, and a wrong
+                // entry here would be untraceable in a bug report.
+                source: "orchestrator_completion",
+            });
+        }
+    }
+    return { unavailable, stillUnchecked };
+}
+function mergeUnavailable(existing, extra) {
+    const cur = Array.isArray(existing) ? [...existing] : [];
+    const seen = new Set(cur.map((u) => JSON.stringify([u?.id, u?.widget, u?.value])));
+    for (const u of extra) {
+        const key = JSON.stringify([u.id, u.widget, u.value]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        cur.push(u);
+    }
+    return cur;
+}
+/**
+ * Every surface in this payload that contradicts "no errors recorded".
+ *
+ * STRUCTURAL ON PURPOSE — the predicate this replaces matched the panel's note
+ * prose (`/no errors recorded since the last execution/`), and that note ships
+ * through `tr()`. It is translated in all twelve bundled locales, so on a
+ * Japanese or French panel the match failed and the clean note survived beside
+ * a populated `unavailable_widget_values`: exactly the #399/#984
+ * self-contradiction, invisible to any English test.
+ */
+function payloadHasDefects(payload) {
+    const nonEmpty = (k) => Array.isArray(payload[k]) && payload[k].length > 0;
+    if (typeof payload.errored_count === "number" && payload.errored_count > 0)
+        return true;
+    if (payload.node_errors != null && Object.keys(payload.node_errors).length > 0)
+        return true;
+    if (payload.last_execution_error != null)
+        return true;
+    if (typeof payload.missing_node_count === "number" && payload.missing_node_count > 0)
+        return true;
+    return (nonEmpty("unavailable_widget_values") ||
+        nonEmpty("missing_models") ||
+        nonEmpty("missing_media") ||
+        nonEmpty("missing_node_types") ||
+        nonEmpty("stale_placeholders"));
+}
+/**
+ * Put audit completeness FIRST so `errored_count: 0` cannot be read as a
+ * finished clean scan, and never ship the panel's "no errors recorded" note
+ * beside something that contradicts it.
+ */
+export function presentGetErrorsAudit(payload) {
+    const incomplete = isGetErrorsAuditIncomplete(payload);
+    const unchecked = asUncheckedList(payload);
+    const uncheckedCount = uncheckedNodeCount(unchecked);
+    const nodeCount = typeof payload.node_count === "number" && Number.isFinite(payload.node_count)
+        ? payload.node_count
+        : null;
+    const checkedCount = nodeCount != null ? Math.max(0, nodeCount - uncheckedCount) : null;
+    const note = payload.note;
+    const rest = { ...payload };
+    delete rest.note;
+    delete rest.audit_complete;
+    delete rest.audit_incomplete_reason;
+    delete rest.checked_count;
+    delete rest.unchecked_count;
+    const out = {};
+    out.audit_complete = !incomplete;
+    if (incomplete) {
+        out.audit_incomplete_reason =
+            payload.unchecked_budget_exhausted === true
+                ? "get_errors ran out of its shared server-call budget"
+                : "some nodes were not judged before the scan stopped";
+    }
+    if (nodeCount != null)
+        out.node_count = nodeCount;
+    if (checkedCount != null)
+        out.checked_count = checkedCount;
+    out.unchecked_count = uncheckedCount;
+    if ("errored_count" in rest) {
+        out.errored_count = rest.errored_count;
+        delete rest.errored_count;
+    }
+    delete rest.node_count;
+    for (const [k, v] of Object.entries(rest)) {
+        if (!(k in out))
+            out[k] = v;
+    }
+    if (incomplete) {
+        const shown = typeof out.errored_count === "number" ? out.errored_count : 0;
+        out.note =
+            `AUDIT INCOMPLETE: ${uncheckedCount} node(s) were not checked. ` +
+                `errored_count (${shown}) counts only the nodes this scan judged — ` +
+                `it is not a clean bill of health for the rest.`;
+    }
+    else if (typeof note === "string" && !payloadHasDefects(payload)) {
+        out.note = note;
+    }
+    return out;
+}
+async function followUpJson(ctx, cmd, timeoutMs, primaryTabId) {
+    const tabBefore = ctx.tabId;
+    try {
+        const res = await ctx.call(cmd, timeoutMs);
+        const tabAfter = ctx.tabId;
+        return {
+            payload: parseToolResultJson(res),
+            stayedOnPrimaryTab: primaryTabId == null || (tabBefore === primaryTabId && tabAfter === primaryTabId),
+        };
+    }
+    catch {
+        return {
+            payload: null,
+            stayedOnPrimaryTab: primaryTabId == null || tabBefore === primaryTabId,
+        };
+    }
+}
+function viewingIdentity(payload) {
+    const raw = payload?.viewing;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const v = raw;
+    const keys = ["workflow_uuid", "workflow", "kind", "scope", "owner_node_id", "title"];
+    const identity = Object.fromEntries(keys.filter((key) => key in v).map((key) => [key, v[key]]));
+    return Object.keys(identity).length > 0 ? identity : null;
+}
+/**
+ * A follow-up may only retire leftovers when it identifies the same live graph
+ * as the primary read. Compare every stable identity field both replies expose;
+ * requiring a shared field makes an omitted/opaque identity fail closed.
+ */
+function sameViewingIdentity(primary, followUp) {
+    const a = viewingIdentity(primary);
+    const b = viewingIdentity(followUp);
+    if (!a || !b)
+        return false;
+    // A UUID/path identity cannot be downgraded to a coincidentally equal root
+    // scope. If either side publishes one, both must publish the same value.
+    for (const key of ["workflow_uuid", "workflow"]) {
+        if (key in a || key in b) {
+            if (!(key in a) || !(key in b) || !Object.is(a[key], b[key]))
+                return false;
+        }
+    }
+    const shared = Object.keys(a).filter((key) => key in b);
+    return shared.length > 0 && shared.every((key) => Object.is(a[key], b[key]));
+}
+/**
+ * After a budget-exhausted graph_get_errors, finish leftover combo checks from
+ * one batched object_info + a targeted graph_query, then present completeness
+ * honestly. Never throws: a failed follow-up still returns the incomplete audit.
+ *
+ * A payload the panel already finished still goes through presentGetErrorsAudit.
+ * Completeness is not consistency: `errored_count: 0` plus a translated
+ * "no errors recorded" note beside `unavailable_widget_values` is a completed
+ * audit that still contradicts itself. Skipping the sanitizer because nobody
+ * was left unchecked is how that contradiction would ship.
+ */
+export async function completeGetErrorsAudit(ctx, res, timeoutMs, primaryTabId) {
+    const payload = parseToolResultJson(res);
+    if (!payload)
+        return res;
+    if (!isGetErrorsAuditIncomplete(payload)) {
+        return rewriteTextPayload(res, presentGetErrorsAudit(payload));
+    }
+    const leftover = asUncheckedList(payload).filter(isRetryableUnchecked);
+    const leftoverIds = [
+        ...new Set(leftover.map((e) => e.id).filter((id) => id != null)),
+    ];
+    if (leftoverIds.length > 0) {
+        const [queryRead, infoRead] = await Promise.all([
+            followUpJson(ctx, {
+                cmd: "graph_query",
+                ids: leftoverIds,
+                fields: "detail",
+                limit: LIMIT_CEILING,
+                max_chars: MAX_CHARS_CEILING,
+            }, timeoutMs, primaryTabId),
+            followUpJson(ctx, { cmd: "graph_get_object_info" }, timeoutMs, primaryTabId),
+        ]);
+        const query = queryRead.payload;
+        const infoReply = infoRead.payload;
+        const objectInfo = infoReply ? objectInfoFromReply(infoReply) : null;
+        const nodes = query ? parseQueryNodes(query) : [];
+        const sameGraph = queryRead.stayedOnPrimaryTab &&
+            infoRead.stayedOnPrimaryTab &&
+            sameViewingIdentity(payload, query);
+        if (sameGraph && objectInfo && nodes.length > 0) {
+            const judged = judgeLeftoverCombos(leftover, nodes, objectInfo);
+            // Non-retryable abstentions (the probe cap, a failed lookup, an unenumerable
+            // path the panel already disclosed) stay; retryable leftovers are replaced by
+            // whatever this pass still could not judge.
+            const nextUnchecked = [
+                ...asUncheckedList(payload).filter((e) => !isRetryableUnchecked(e)),
+                ...judged.stillUnchecked,
+            ];
+            payload.unchecked_nodes = nextUnchecked;
+            // The panel's note counts the PRE-completion list. Drop it rather than
+            // leave "NOT CHECKED: 40" next to a shorter remainder.
+            delete payload.unchecked_nodes_note;
+            if (nextUnchecked.length === 0) {
+                delete payload.unchecked_nodes;
+            }
+            const stillRetryable = nextUnchecked.some(isRetryableUnchecked);
+            if (!stillRetryable) {
+                delete payload.unchecked_budget_exhausted;
+                delete payload.unchecked_class_limit;
+            }
+            if (judged.unavailable.length) {
+                const merged = mergeUnavailable(payload.unavailable_widget_values, judged.unavailable);
+                const added = merged.length - (Array.isArray(payload.unavailable_widget_values)
+                    ? payload.unavailable_widget_values.length
+                    : 0);
+                payload.unavailable_widget_values = merged;
+                // The panel's note carries a COUNT of the pre-completion list
+                // (comboAvailabilityNote), so appending to the list without replacing it
+                // ships "1 widget value(s)" above two entries — the same stale-count
+                // defect the unchecked_nodes_note delete above exists to avoid.
+                if (added > 0) {
+                    payload.unavailable_widget_values_note =
+                        `LIVE SCAN + ORCHESTRATOR COMPLETION: ${merged.length} widget value(s) the server ` +
+                            `does not offer, ${added} of them judged after the panel's scan ran out of budget, ` +
+                            `from one batched /object_info read and marked source:"orchestrator_completion". ` +
+                            `Values on an UPLOAD input that the combo list cannot enumerate were NOT judged ` +
+                            `here — those stay in unchecked_nodes.`;
+                }
+            }
+            payload.audit_completed_by = "orchestrator";
+        }
+    }
+    return rewriteTextPayload(res, presentGetErrorsAudit(payload));
+}
+//# sourceMappingURL=get-errors-audit.js.map