jev-agent-tools 0.2.0 → 0.3.0

package/dist/tools/locate.js

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { canonicalPath } from "../adapters/canonical-path.js";
+import { resolveEvidenceContext, withEvidenceContext, } from "../adapters/evidence-context.js";
 import { shareGitInventory } from "../adapters/git-inventory.js";
 import { readLocateFile, scanRange } from "../adapters/locate-file.js";
 import { loadSyntaxParser } from "../adapters/syntax.js";
@@ -8,12 +8,17 @@ import { CHOICE_MAX_OPTIONS, LOCATE_GRAY_MIN, LOCATE_MIN_KB, LOCATE_SECTION_MAX_
 import { locateDisplay, outlineEvidence, sectionOutline, sectionState, sectionStateFits, } from "../core/locate.js";
 import { buildEnvelope, } from "../core/output.js";
 import { needsReverse, pointerQuestion, readPointer } from "../core/pointer.js";
+import { answerItemFromInput, buildResultReport, contextFromEvidence, known, unknown, } from "../core/result-report.js";
 import { sectionFile } from "../core/sections.js";
 import { interpolate } from "../describe.js";
-import { renderEnvelope } from "../render.js";
+import { renderResultReport } from "../render.js";
 import { NOT_CONFIGURED } from "../texts/configuration.js";
 import { LOCATE_DESCRIPTION } from "../texts/locate.js";
-const parameters = Type.Object({ path: Type.String({ minLength: 1 }), goal: Type.String({ minLength: 1 }) }, { additionalProperties: false });
+const parameters = Type.Object({
+    root: Type.Optional(Type.String()),
+    path: Type.String({ minLength: 1 }),
+    goal: Type.String({ minLength: 1 }),
+}, { additionalProperties: false });
 export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
     const { host, runtime, exec: execute } = dependencies;
     return {
@@ -30,11 +35,87 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
             }),
         async execute(_id, args, signal, _update, ctx) {
             const client = dependencies.client;
-            const cwd = await canonicalPath(ctx.cwd);
+            const evidence = await resolveEvidenceContext(ctx.cwd, args.root, {
+                exec: execute,
+                signal,
+                origin: dependencies.evidenceOrigin,
+            });
+            const evidenceContext = evidence.context;
+            const cwd = evidence.ok ? evidence.cwd : evidenceContext.authority.path;
             const started = performance.now();
             const exec = shareGitInventory(execute);
             const results = [];
             const limitations = [];
+            const context = contextFromEvidence(evidenceContext);
+            const diagnostics = [];
+            const actions = [];
+            const auxiliary = {
+                controls: { fresh: 0, cache: 0, notJudged: 0, static: 0 },
+                passages: { fresh: 0, cache: 0, notJudged: 0 },
+            };
+            let primary;
+            let control;
+            let requiredControl = false;
+            let failureCause = "invalid_response";
+            const raw = (answer) => answer.type === "choice"
+                ? Object.entries(answer.probabilities).map(([label, probability]) => ({
+                    label,
+                    value: label,
+                    probability: known(probability),
+                }))
+                : [];
+            const diagnose = (cause, fact, members = []) => {
+                const id = `d${diagnostics.length + 1}`, actionId = `a${actions.length + 1}`;
+                const code = cause === "invalid_root"
+                    ? "correct_context"
+                    : cause === "not_configured"
+                        ? "configure_client"
+                        : cause === "transport_failure" || cause === "service_unavailable"
+                            ? "recover_service"
+                            : "inspect_native";
+                actions.push({
+                    id: actionId,
+                    code,
+                    target: known(args.path),
+                    scope: { kind: "call" },
+                    condition: code === "correct_context"
+                        ? "If the requested root is incorrect"
+                        : code === "recover_service"
+                            ? "Only after service recovery is observed"
+                            : "If the range decision remains open",
+                    instruction: code === "correct_context"
+                        ? "Use the exact registered worktree top-level; no fallback was performed."
+                        : code === "configure_client"
+                            ? "Configure the Jev client or inspect the file natively."
+                            : "Read or search the cited file within existing permissions; revisit Jev only with decisive new evidence or materially changed context.",
+                    repeatUnchanged: false,
+                });
+                diagnostics.push({
+                    id,
+                    cause,
+                    fact,
+                    target: known(cause === "invalid_root" ? (args.root ?? cwd) : args.path),
+                    origin: cause === "invalid_root" || cause === "forbidden_path"
+                        ? "input"
+                        : cause === "control_failure"
+                            ? "control"
+                            : cause === "session_budget"
+                                ? "budget"
+                                : cause === "service_unavailable" ||
+                                    cause === "transport_failure" ||
+                                    cause === "invalid_response" ||
+                                    cause === "provider_context_refusal" ||
+                                    cause === "not_configured"
+                                    ? "provider"
+                                    : "collection",
+                    scope: { kind: "call" },
+                    effect: "blocking",
+                    material: true,
+                    omittedMembers: members,
+                    memberCount: known(members.length),
+                    actionIds: [actionId],
+                });
+            };
             const finish = (input) => {
                 const usage = results.reduce((sum, result) => ({
                     inputTokens: sum.inputTokens + (result.usage?.inputTokens ?? 0),
@@ -61,23 +142,159 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
                         elapsedMs: performance.now() - started,
                     },
                 });
+                if (input.refusal)
+                    diagnose(failureCause, input.refusal);
+                if (input.answers?.[0] && primary?.source)
+                    actions.push({
+                        id: `a${actions.length + 1}`,
+                        code: "inspect_native",
+                        target: known(input.answers[0].label === "none"
+                            ? args.path
+                            : input.answers[0].label),
+                        scope: { kind: "group", groupIds: ["pointer"] },
+                        condition: "If the range decision remains open",
+                        instruction: input.answers[0].label === "none"
+                            ? "Search elsewhere for the goal; read any cited alternative range if the result is unsure. Do not retry unchanged evidence."
+                            : "Read the current primary and alternative ranges; retain uncertainty if no decisive new evidence is available. Do not retry unchanged evidence.",
+                        repeatUnchanged: false,
+                    });
+                if (!input.refusal &&
+                    (!primary?.source || (requiredControl && !control?.source)))
+                    diagnose("invalid_response", "pointer decision lacks established answer provenance or its required control");
+                const common = {
+                    id: "pointer",
+                    kind: "pointer",
+                    label: args.path,
+                    groupId: "pointer",
+                    evidence: primary
+                        ? [
+                            {
+                                target: args.path,
+                                canonicalPath: evidenceContext.effectiveRoot
+                                    ? known(`${evidenceContext.effectiveRoot.path}/${args.path}`)
+                                    : unknown("file admission not established"),
+                                aliases: [],
+                                side: "current",
+                                revision: context.resolvedBase,
+                            },
+                        ]
+                        : [],
+                    diagnosticIds: diagnostics.map((d) => d.id),
+                    actionIds: actions.map((a) => a.id),
+                };
+                if (input.answers?.[0])
+                    common.label = input.answers[0].label;
+                const displayed = input.answers?.[0];
+                let item = { ...common, treatment: "not_judged", source: "none" };
+                if (displayed &&
+                    primary?.type === "choice" &&
+                    primary.source &&
+                    (!requiredControl || (control?.type === "choice" && control.source))) {
+                    auxiliary.passages[primary.source]--;
+                    item = answerItemFromInput(common, {
+                        ...displayed,
+                        answer: primary,
+                        publicResult: displayed.value?.head ?? primary.choice,
+                        reason: [...limitations, ...(input.limitations ?? [])]
+                            .map((limit) => limit.fact)
+                            .join("; "),
+                        rawValues: raw(primary),
+                        reportControls: control?.type === "choice" && control.source
+                            ? [
+                                {
+                                    id: "pointer-order",
+                                    kind: "order",
+                                    source: control.source,
+                                    outcome: displayed.orderDependent
+                                        ? "order-dependent"
+                                        : "consistent",
+                                    rawValues: raw(control),
+                                },
+                            ]
+                            : [],
+                    });
+                }
+                const report = buildResultReport({
+                    tool: "jev_locate_in_file",
+                    context,
+                    items: [item],
+                    diagnostics,
+                    actions,
+                    metrics: {
+                        ...metrics,
+                        costUsd: results.every((r) => !r.calls || r.usage !== undefined)
+                            ? usage.costUsd
+                            : undefined,
+                        elapsedMs: performance.now() - started,
+                    },
+                    auxiliary,
+                    total: known(1),
+                    refused: Boolean(input.refusal &&
+                        (failureCause === "invalid_root" ||
+                            failureCause === "forbidden_path" ||
+                            failureCause === "outside_inventory" ||
+                            failureCause === "group_too_large" ||
+                            failureCause === "evidence_too_large")),
+                });
                 runtime.session.record(envelope);
                 runtime.guide.deliver(ctx);
                 return {
-                    content: [{ type: "text", text: renderEnvelope(envelope) }],
-                    details: { results },
+                    content: [
+                        {
+                            type: "text",
+                            text: renderResultReport(report, {
+                                details: {
+                                    lines: [
+                                        ...envelope.lines,
+                                        {
+                                            type: "list",
+                                            title: "pointer reservations",
+                                            items: [...limitations, ...(input.limitations ?? [])].map((limit) => limit.fact),
+                                        },
+                                        ...(displayed
+                                            ? [
+                                                {
+                                                    type: "list",
+                                                    title: "read ranges",
+                                                    items: [
+                                                        ...(displayed.label === "none"
+                                                            ? []
+                                                            : [displayed.label]),
+                                                        ...(displayed.candidates ?? [])
+                                                            .filter((candidate) => candidate.label !== "none")
+                                                            .map((candidate) => `${candidate.label} (${candidate.value.p})`),
+                                                    ],
+                                                },
+                                            ]
+                                            : []),
+                                    ],
+                                },
+                            }),
+                        },
+                    ],
+                    details: { results, evidenceContext, result: report },
                     ...hostUsage(host.isOmp, results.some((r) => r.usage) ? usage : undefined),
                 };
             };
+            if (!evidence.ok) {
+                failureCause = evidence.cause ?? "invalid_root";
+                return finish({ refusal: evidence.error });
+            }
+            failureCause = "file_unavailable";
             const file = await readLocateFile(cwd, args.path, signal, exec);
-            if (!file.ok)
+            if (!file.ok) {
+                failureCause = file.cause ?? "file_unavailable";
                 return finish({ refusal: file.error });
+            }
+            failureCause = "outside_inventory";
             if (file.bytes < LOCATE_MIN_KB * 1000)
                 return finish({
                     refusal: `small file (${file.lines} lines): read it directly`,
                 });
-            if (!client)
+            if (!client) {
+                failureCause = "not_configured";
                 return finish({ refusal: NOT_CONFIGURED });
+            }
             let sections;
             if (file.kind === "whole") {
                 const parser = await loadParser();
@@ -115,8 +332,56 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
                 });
             }
             const sectionCount = sections.length;
+            context.inventories.push({
+                id: "sections",
+                kind: "sections",
+                rules: [
+                    file.kind === "whole"
+                        ? "declarations or heuristic sections from complete file"
+                        : "bounded window outline",
+                ],
+                restrictions: [
+                    args.path,
+                    ...sections.map((section) => `${section.id}: ${section.start}-${section.end}`),
+                ],
+                discovered: known(sectionCount),
+                considered: known(sectionCount),
+                scopeRestricted: true,
+                criteria: [],
+            });
+            if (!sectionCount) {
+                diagnose("collection_empty", "no sections discovered; no pointer judgment");
+                return finish({});
+            }
+            failureCause = "group_too_large";
             const judge = async (candidates, outline = false) => {
-                const state = sectionState(args.path, args.goal, candidates, outline);
+                primary = undefined;
+                control = undefined;
+                requiredControl = false;
+                const inventory = context.inventories.find((inventory) => inventory.id === "pointer-candidates");
+                const restricted = {
+                    id: "pointer-candidates",
+                    kind: "sections",
+                    rules: ["actual candidates for the latest pointer stage"],
+                    restrictions: [
+                        args.path,
+                        ...candidates.map((section) => `${section.id}: ${section.start}-${section.end}`),
+                    ],
+                    discovered: known(candidates.length),
+                    considered: known(candidates.length),
+                    scopeRestricted: true,
+                    criteria: [],
+                };
+                if (inventory)
+                    Object.assign(inventory, restricted);
+                else
+                    context.inventories.push(restricted);
+                const state = withEvidenceContext(sectionState(args.path, args.goal, candidates, outline), evidenceContext);
+                if (JSON.stringify(state).length > STATE_MAX_CHARS)
+                    return {
+                        ok: false,
+                        error: `required evidence exceeds STATE_MAX_CHARS=${STATE_MAX_CHARS}`,
+                    };
                 const ask = async (reverse) => {
                     const result = await client.judge(state, {
                         pointer: pointerQuestion({
@@ -129,12 +394,36 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
                         signal,
                         ...runtime.session.requestGate(),
                         beforeRequest: (n) => runtime.session.admit(n),
+                        admissionCause: () => "session_budget",
                         onUsage: (usage) => runtime.session.recordUsage(usage),
                     });
                     results.push(result);
+                    if (!result.ok) {
+                        failureCause = result.failureCause ?? "invalid_response";
+                        if (reverse)
+                            auxiliary.controls.notJudged++;
+                        else
+                            auxiliary.passages.notJudged++;
+                    }
                     if (!result.ok)
                         return { ok: false, error: result.error };
                     const answer = result.answers.pointer;
+                    if (reverse)
+                        control = answer;
+                    else
+                        primary = answer;
+                    if (answer?.type === "unjudged")
+                        failureCause = answer.cause ?? "invalid_response";
+                    if (answer?.type === "choice" && answer.source) {
+                        if (reverse)
+                            auxiliary.controls[answer.source]++;
+                        else
+                            auxiliary.passages[answer.source]++;
+                    }
+                    else if (reverse)
+                        auxiliary.controls.notJudged++;
+                    else
+                        auxiliary.passages.notJudged++;
                     return answer?.type === "choice"
                         ? { ok: true, probabilities: answer.probabilities }
                         : {
@@ -149,24 +438,32 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
                     return first;
                 let pointer = readPointer(first.probabilities);
                 if (needsReverse(first.probabilities, candidates.length)) {
+                    requiredControl = true;
                     const second = await ask(true);
-                    if (!second.ok)
+                    if (!second.ok) {
+                        if (failureCause === "invalid_response")
+                            failureCause = "control_failure";
                         return second;
+                    }
                     pointer = readPointer(first.probabilities, second.probabilities);
                 }
                 return { ok: true, ...pointer };
             };
-            const fits = (candidates) => sectionStateFits(args.path, args.goal, candidates);
+            const emptyState = sectionState(args.path, args.goal, []);
+            const contextChars = JSON.stringify(withEvidenceContext(emptyState, evidenceContext))
+                .length - JSON.stringify(emptyState).length;
+            const evidenceMaxChars = STATE_MAX_CHARS - contextChars;
+            const fits = (candidates) => sectionStateFits(args.path, args.goal, candidates, false, evidenceMaxChars);
             const twoStage = file.kind === "outline" || !fits(sections);
             let planUnsure = false;
             if (twoStage) {
-                const outline = sectionOutline(args.path, args.goal, sections);
+                const outline = sectionOutline(args.path, args.goal, sections, evidenceMaxChars);
                 if (outline.length < 2 || outline.length >= CHOICE_MAX_OPTIONS)
                     return finish({
                         refusal: "No usable multi-section plan fits the budget; use grep or read directly.",
                     });
-                const evidence = outlineEvidence(args.path, args.goal, outline);
-                if (!sectionStateFits(args.path, args.goal, evidence))
+                const evidence = outlineEvidence(args.path, args.goal, outline, evidenceMaxChars);
+                if (!fits(evidence))
                     return finish({
                         refusal: "Block plan exceeds the state budget; use grep.",
                     });
@@ -217,8 +514,10 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
                 }
                 if (file.kind === "outline") {
                     const selected = await scanRange(cwd, args.path, block, signal, exec);
-                    if (!selected.ok)
+                    if (!selected.ok) {
+                        failureCause = selected.cause ?? "file_unavailable";
                         return finish({ refusal: selected.error });
+                    }
                     const lines = selected.text.split("\n");
                     sections = sections
                         .filter((s) => s.start >= block.start && s.end <= block.end)
@@ -271,7 +570,7 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
             const displayed = locateDisplay(args.path, sections, pointer.ranked, shrunk || planUnsure);
             if (!displayed)
                 return finish({ refusal: "Pointer probabilities missing." });
-            const { primary, band, candidates } = displayed;
+            const { primary: displayedPrimary, band, candidates } = displayed;
             if (band === "unsure" || head.id === "none")
                 limitations.push({
                     fact: head.id === "none"
@@ -282,14 +581,14 @@ export function createLocateTool(dependencies, loadParser = loadSyntaxParser) {
             return finish({
                 answers: [
                     {
-                        ...primary,
+                        ...displayedPrimary,
                         band,
                         orderDependent: pointer.orderDependent,
                         candidates,
                     },
                 ],
                 lines: head.id !== "none"
-                    ? [{ type: "list", title: "read", items: [primary.label] }]
+                    ? [{ type: "list", title: "read", items: [displayedPrimary.label] }]
                     : [],
                 limitations: [
                     {

package/dist/tools/review-report.js

@@ -0,0 +1,230 @@
+import { answerItemFromInput, buildResultReport, contextFromEvidence, known, unknown, } from "../core/result-report.js";
+export function reportMetrics(envelope) {
+    const line = envelope.lines.find((line) => line.type === "yield");
+    if (line?.type !== "yield")
+        throw new Error("Report metrics missing from envelope");
+    return line.value;
+}
+export function controlsFor(id, judgment, witnessIds) {
+    const batches = judgment.batches?.filter((batch) => batch.questionIds.includes(id));
+    const responses = batches?.length
+        ? batches.map((batch) => batch.answers)
+        : [judgment.ok ? judgment.answers : {}];
+    return responses.flatMap((answers) => witnessIds.map((witnessId) => answers[witnessId] ?? {
+        type: "unjudged",
+        reason: "Required witness response unavailable",
+    }));
+}
+/** Producer-owned inventory: register before admission, retain negative answers too. */
+export class ReviewReport {
+    items = new Map();
+    diagnostics = [];
+    actions = [];
+    inventories = [];
+    auxiliary = {
+        controls: { fresh: 0, cache: 0, notJudged: 0, static: 0 },
+        passages: { fresh: 0, cache: 0, notJudged: 0 },
+    };
+    refusal = false;
+    missingWork = false;
+    totalUnknown = false;
+    countControls(judgment, ids) {
+        const batches = judgment.batches ?? [
+            { answers: judgment.ok ? judgment.answers : {}, questionIds: ids },
+        ];
+        for (const batch of batches)
+            for (const id of ids) {
+                if (!batch.questionIds.includes(id) && judgment.batches)
+                    continue;
+                const answer = batch.answers[id];
+                this.auxiliary.controls[answer && answer.type !== "unjudged" && answer.source
+                    ? answer.source
+                    : "notJudged"]++;
+            }
+    }
+    expect(id, label, kind, groupId = id) {
+        if (!this.items.has(id))
+            this.items.set(id, {
+                id,
+                label,
+                kind,
+                groupId,
+                evidence: [],
+                diagnosticIds: [],
+                actionIds: [],
+                treatment: "not_judged",
+                source: "none",
+            });
+    }
+    diagnose(cause, fact, target, itemIds = [], blocking = true, omittedMembers = []) {
+        const id = `diagnostic:${this.diagnostics.length}`;
+        const actionId = `action:${this.actions.length}`;
+        const scope = itemIds.length
+            ? { kind: "item", itemIds }
+            : { kind: "call" };
+        const code = cause === "invalid_root" || cause === "invalid_base"
+            ? "correct_context"
+            : cause === "not_configured"
+                ? "configure_client"
+                : cause === "service_unavailable" || cause === "transport_failure"
+                    ? "recover_service"
+                    : "inspect_native";
+        this.actions.push({
+            id: actionId,
+            code,
+            target: target === undefined
+                ? unknown("target not established")
+                : known(target),
+            scope,
+            condition: "Only after the named context, evidence, or service condition materially changes; otherwise use native inspection or the retained runner plan.",
+            instruction: code === "correct_context"
+                ? "Correct the named repository root or base if it does not match the intended comparison."
+                : code === "configure_client"
+                    ? "Configure the required Jev endpoint before requesting judgment; use native inspection meanwhile."
+                    : code === "recover_service"
+                        ? "Establish service recovery before another useful judgment request; do not repeat the unchanged call."
+                        : "Inspect the named evidence natively or execute the retained runner plan; preserve this limitation.",
+            repeatUnchanged: false,
+        });
+        this.diagnostics.push({
+            id,
+            cause,
+            fact,
+            target: target === undefined
+                ? unknown("target not established")
+                : known(target),
+            origin: cause === "control_failure"
+                ? "control"
+                : cause === "call_budget" || cause === "session_budget"
+                    ? "budget"
+                    : cause === "not_configured" ||
+                        cause === "service_unavailable" ||
+                        cause === "transport_failure" ||
+                        cause === "invalid_response" ||
+                        cause === "provider_context_refusal"
+                        ? "provider"
+                        : "collection",
+            scope,
+            effect: blocking ? "blocking" : "reservation",
+            material: true,
+            omittedMembers,
+            memberCount: known(omittedMembers.length),
+            actionIds: [actionId],
+        });
+        for (const itemId of itemIds) {
+            const item = this.items.get(itemId);
+            if (item) {
+                item.diagnosticIds.push(id);
+                item.actionIds.push(actionId);
+            }
+        }
+    }
+    static(id, reason, selected) {
+        const item = this.items.get(id);
+        if (!item)
+            throw new Error(`Unregistered review result ${id}`);
+        this.items.set(id, {
+            ...item,
+            treatment: "static",
+            source: "none",
+            staticReason: reason,
+            ...(selected === undefined ? {} : { selection: { selected, reason } }),
+        });
+    }
+    answer(id, answer, input = {}, controls = [], countControls = true) {
+        const item = this.items.get(id);
+        if (!item)
+            throw new Error(`Unregistered review result ${id}`);
+        const unavailable = !answer || answer.type === "unjudged" || !answer.source;
+        const missingControl = controls.some((control) => control.type === "unjudged" || !control.source);
+        if (countControls)
+            for (const control of controls)
+                this.auxiliary.controls[control.type === "unjudged" || !control.source
+                    ? "notJudged"
+                    : control.source]++;
+        if (unavailable || missingControl) {
+            this.diagnose(missingControl
+                ? "control_failure"
+                : answer?.type === "unjudged"
+                    ? (answer.cause ?? "invalid_response")
+                    : "invalid_response", missingControl
+                ? "Required control response is unavailable; the requested group has no admissible judgment."
+                : answer?.type === "unjudged"
+                    ? answer.reason
+                    : "Requested answer or its transport provenance is unavailable.", item.label, [id]);
+            return;
+        }
+        const valid = answer;
+        const rawValues = valid.type === "bool"
+            ? [{ label: "true", value: true, probability: known(valid.p) }]
+            : Object.entries(valid.probabilities).map(([label, p]) => ({
+                label,
+                value: label,
+                probability: known(p),
+            }));
+        this.items.set(id, answerItemFromInput(item, {
+            label: item.label,
+            answer: valid,
+            source: valid.source,
+            band: "verdict",
+            rawValues,
+            ...input,
+            reportControls: controls.map((control, index) => {
+                const source = control.source;
+                if (!source)
+                    throw new Error("Admitted control lacks provenance");
+                return {
+                    id: `${id}:control:${index}`,
+                    kind: "integrity",
+                    source,
+                    outcome: control.type === "bool"
+                        ? String(control.p)
+                        : control.type === "choice"
+                            ? control.choice
+                            : control.type === "score"
+                                ? String(control.score)
+                                : control.reason,
+                    rawValues: control.type === "choice" || control.type === "score"
+                        ? Object.entries(control.probabilities).map(([label, p]) => ({
+                            label,
+                            value: label,
+                            probability: known(p),
+                        }))
+                        : control.type === "bool"
+                            ? [
+                                {
+                                    label: "true",
+                                    value: true,
+                                    probability: known(control.p),
+                                },
+                            ]
+                            : [],
+                };
+            }),
+        }));
+    }
+    failure(judgment, ids, cause) {
+        this.diagnose(cause ??
+            (!judgment.ok ? judgment.cause : undefined) ??
+            judgment.failureCause ??
+            "invalid_response", judgment.ok ? "Required responses unavailable" : judgment.error, undefined, ids);
+    }
+    build(tool, evidence, metrics) {
+        const context = contextFromEvidence(evidence);
+        context.inventories = this.inventories;
+        return buildResultReport({
+            tool,
+            context,
+            items: [...this.items.values()],
+            diagnostics: this.diagnostics,
+            actions: this.actions,
+            metrics,
+            auxiliary: this.auxiliary,
+            total: this.totalUnknown || (!this.inventories.length && !this.items.size)
+                ? unknown("Expected inventory was not completely enumerable")
+                : known(this.items.size),
+            refused: this.refusal,
+            missingWork: this.missingWork,
+        });
+    }
+}