wotann 0.5.39 → 0.5.40

package/dist/orchestration/ports-bridge.js

@@ -0,0 +1,712 @@
+/**
+ * ports-bridge — business-level bridge functions for the 4 zombie ports.
+ *
+ * The audit finding #8 surfaced that four port primitives shipped under
+ * `src/ports/*` are library-only — they're re-exported from `src/lib.ts`
+ * but no internal consumer reaches them. They were never callable from
+ * the daemon's RPC surface, because each requires dependency injection
+ * (converse callback, search provider, graph store, dom adapter) that
+ * a JSON-RPC frame cannot transport.
+ *
+ * This module is the missing seam:
+ *
+ *   - Each port is a *library primitive*. The bridge constructs the
+ *     dependency-injected primitive INTERNALLY from business-level inputs
+ *     (a chatdev waterfall spec + query, a research query, a text blob to
+ *     ingest into a memory graph, a DOM snapshot to locate against).
+ *
+ *   - The daemon RPC handlers (src/daemon/rpc-handlers/ports-rpc.ts) call
+ *     these bridge functions one-to-one. They are the *only* in-process
+ *     consumer; the bridge does not call them back. No cycle.
+ *
+ *   - Each bridge function follows the QB#3 honest-stub policy: if a real
+ *     dependency cannot be reached (no LLM provider for chatdev, no
+ *     search provider for deer-flow), the bridge returns an `ok:false`
+ *     envelope with a verbatim `reason` string. It NEVER silently
+ *     succeeds with mock data.
+ *
+ *   - For mem0-graph and scrapling-adaptive the in-memory backends are
+ *     always available, so the bridge wires those by default and only
+ *     surfaces failure when the input itself is malformed.
+ *
+ * QB bars honoured:
+ *   QB#3  honest stub — no silent success
+ *   QB#7  zero module-level mutable state — every bridge call constructs
+ *         its own primitives
+ *   QB#10 errors surface verbatim
+ *   QB#13 no direct env reads except through the audit-friendly
+ *         `WOTANN_*` knobs documented per-function
+ *   QB#19 every type/exports is consumed by at least one handler
+ *
+ * Imports use ESM `.js` suffixes; strict TypeScript with ES2022 target.
+ */
+import { promises as fsp } from "node:fs";
+import { dirname } from "node:path";
+import { runWaterfall, defaultWaterfall, fixtureConverse, DEFAULT_ROLES, } from "../ports/chatdev-waterfall.js";
+import { runResearch, fixturePipeline, } from "../ports/deer-flow-research.js";
+import { ingestText, neighborhood, createInMemoryGraphStore, } from "../ports/mem0-graph-memory.js";
+import { adaptiveLocate, createInMemoryFingerprintStore, } from "../ports/scrapling-adaptive.js";
+import { resolveWotannHomeSubdir } from "../utils/wotann-home.js";
+import { writeFileAtomic } from "../utils/atomic-io.js";
+/**
+ * Build a converse function that drives one phase through the runtime.
+ * On any provider error it surfaces the message verbatim (QB#10).
+ */
+function buildRuntimeConverse(runtime) {
+    return async (rolePair, inputArtifact, charter) => {
+        const phaseId = `${rolePair.initiator.id}->${rolePair.responder.id}`;
+        const systemPrompt = [
+            `You are pairing the roles ${rolePair.initiator.name} and ${rolePair.responder.name}.`,
+            `Their joint charter:`,
+            charter,
+            `Refine the incoming artifact and respond with the refined artifact only.`,
+            `Do not invent new sections; thread the artifact forward.`,
+        ].join("\n");
+        let assistantText;
+        try {
+            assistantText = await runtime.complete(inputArtifact, systemPrompt);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                phaseId,
+                ok: false,
+                reason: `runtime converse threw: ${msg}`,
+                transcript: [
+                    {
+                        speakerRoleId: rolePair.initiator.id,
+                        text: inputArtifact,
+                        meta: { kind: "runtime-input" },
+                    },
+                ],
+                artifact: inputArtifact,
+            };
+        }
+        return {
+            phaseId,
+            ok: true,
+            reason: null,
+            transcript: [
+                {
+                    speakerRoleId: rolePair.initiator.id,
+                    text: inputArtifact,
+                    meta: { kind: "runtime-input" },
+                },
+                {
+                    speakerRoleId: rolePair.responder.id,
+                    text: assistantText,
+                    meta: { kind: "runtime-output" },
+                },
+            ],
+            artifact: assistantText.length > 0 ? assistantText : inputArtifact,
+        };
+    };
+}
+function resolveRoleById(id) {
+    for (const r of Object.values(DEFAULT_ROLES)) {
+        if (r.id === id)
+            return r;
+    }
+    return null;
+}
+/**
+ * Bridge: run a ChatDev waterfall.
+ *
+ * @param spec   Optional phase override. When absent the default 5-phase
+ *               waterfall (Demand -> Design -> Implement -> Review -> Test)
+ *               is used. Phase role ids must reference DEFAULT_ROLES.
+ * @param query  The seed artifact handed to the first phase.
+ * @param options Runtime ref + fixture override flag.
+ */
+export async function runChatDevWaterfall(spec, query, options = {}) {
+    if (typeof query !== "string" || query.trim().length === 0) {
+        return { ok: false, reason: "query must be a non-empty string" };
+    }
+    const useRuntime = !options.forceFixture && options.runtime !== undefined;
+    // QB#3: when a runtime is requested but unreachable we never silently
+    // swap in fixtures — the caller asked for runtime mode. forceFixture
+    // is the explicit opt-in for fixture mode.
+    if (options.runtime !== undefined && options.forceFixture) {
+        // explicit fixture mode wins — caller asked for it
+    }
+    const converse = useRuntime
+        ? buildRuntimeConverse(options.runtime)
+        : fixtureConverse();
+    let phases;
+    if (spec?.phases && spec.phases.length > 0) {
+        const built = [];
+        for (const p of spec.phases) {
+            const initiator = resolveRoleById(p.initiatorId);
+            const responder = resolveRoleById(p.responderId);
+            if (!initiator || !responder) {
+                return {
+                    ok: false,
+                    reason: `unknown role id in phase '${p.id}': initiatorId='${p.initiatorId}', responderId='${p.responderId}'. Valid: ${Object.keys(DEFAULT_ROLES).join(", ")}`,
+                };
+            }
+            built.push({
+                id: p.id,
+                description: p.description,
+                initiator,
+                responder,
+                converse,
+            });
+        }
+        phases = built;
+    }
+    else {
+        // Default waterfall — replace the fixture converser on every phase
+        // with the runtime-backed one when runtime mode is active.
+        const base = defaultWaterfall();
+        phases = base.map((ph) => ({ ...ph, converse }));
+    }
+    const waterfallOptions = spec?.globalCharter
+        ? { seed: query, globalCharter: spec.globalCharter }
+        : { seed: query };
+    const result = await runWaterfall(phases, waterfallOptions);
+    return {
+        ok: true,
+        result,
+        mode: useRuntime ? "runtime" : "fixture",
+    };
+}
+/**
+ * Build a planner that asks the runtime to decompose the question into
+ * sub-questions and parses a JSON array out of the response. If parsing
+ * fails we fall back to one heuristic sub-question (the original
+ * question) — that's honest: we tried and got a malformed response, so
+ * we still do one researcher pass.
+ */
+function buildRuntimePlanner(runtime, maxSubQuestions) {
+    return async (query) => {
+        const systemPrompt = [
+            `You are decomposing a research query into sub-questions.`,
+            `Respond ONLY with a JSON array of up to ${maxSubQuestions} sub-questions.`,
+            `Format: [{ "id": "subq-1", "text": "...", "rationale": "..." }, ...]`,
+        ].join("\n");
+        let response;
+        try {
+            response = await runtime.complete(query.question, systemPrompt);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`planner runtime failed: ${msg}`);
+        }
+        const parsed = tryParseSubQuestions(response, maxSubQuestions);
+        if (parsed.length > 0)
+            return parsed;
+        return [
+            {
+                id: "subq-1",
+                text: query.question,
+                rationale: `runtime planner returned no parseable sub-questions; using original question. Raw: ${response.slice(0, 200)}`,
+            },
+        ];
+    };
+}
+function tryParseSubQuestions(raw, max) {
+    // Extract first JSON array between brackets.
+    const match = raw.match(/\[[\s\S]*\]/);
+    if (!match)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(match[0]);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (let i = 0; i < parsed.length && out.length < max; i++) {
+        const entry = parsed[i];
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const obj = entry;
+        const text = typeof obj["text"] === "string" ? obj["text"] : null;
+        if (!text || text.length === 0)
+            continue;
+        const id = typeof obj["id"] === "string" && obj["id"].length > 0 ? obj["id"] : `subq-${out.length + 1}`;
+        const rationale = typeof obj["rationale"] === "string" ? obj["rationale"] : "";
+        out.push({ id, text, rationale });
+    }
+    return out;
+}
+/**
+ * Build a researcher that gathers evidence via the SearchProvider and
+ * (optionally) summarises via the runtime. If the runtime is absent
+ * the summary is empty — honest: we didn't have an LLM to write one.
+ */
+function buildResearcher(searchProvider, runtime) {
+    return async (subQuestion) => {
+        let hits;
+        try {
+            hits = await searchProvider(subQuestion.text);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                subQuestionId: subQuestion.id,
+                evidence: [],
+                summary: "",
+                error: `search provider threw: ${msg}`,
+            };
+        }
+        const evidence = hits.map((h) => ({
+            source: h.url,
+            snippet: h.snippet,
+            meta: {
+                title: h.title,
+                ...(h.sourceEngine ? { engine: h.sourceEngine } : {}),
+            },
+        }));
+        let summary = "";
+        if (runtime !== undefined && evidence.length > 0) {
+            const systemPrompt = [
+                `You are summarising research evidence for ONE sub-question.`,
+                `Cite each piece by index. Be terse — 3-5 sentences max.`,
+            ].join("\n");
+            const prompt = [
+                `Sub-question: ${subQuestion.text}`,
+                `Evidence:`,
+                ...evidence.map((e, i) => `[${i + 1}] ${e.source}: ${e.snippet}`),
+            ].join("\n");
+            try {
+                summary = await runtime.complete(prompt, systemPrompt);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    subQuestionId: subQuestion.id,
+                    evidence,
+                    summary: "",
+                    error: `summariser runtime failed: ${msg}`,
+                };
+            }
+        }
+        return {
+            subQuestionId: subQuestion.id,
+            evidence,
+            summary,
+            error: null,
+        };
+    };
+}
+/**
+ * Build a reporter that synthesises findings into a final report. With
+ * no runtime ref the synthesis is a deterministic concatenation of the
+ * findings' summaries — honest stub.
+ */
+function buildReporter(runtime) {
+    return async (query, _subQuestions, findings) => {
+        const allCitations = [];
+        for (const f of findings) {
+            for (const c of f.evidence)
+                allCitations.push(c);
+        }
+        if (!runtime) {
+            const synthesis = findings
+                .filter((f) => f.summary.length > 0 || f.evidence.length > 0)
+                .map((f) => f.summary || `(${f.evidence.length} pieces of evidence)`)
+                .join("\n\n");
+            return { synthesis, citations: allCitations };
+        }
+        const systemPrompt = [
+            `You are writing the final research report.`,
+            `Cite each piece of evidence by its [source] index.`,
+            `Structure: brief intro, then per-aspect findings, then closing summary.`,
+        ].join("\n");
+        const prompt = [
+            `Research question: ${query.question}`,
+            `Findings:`,
+            ...findings.map((f, i) => `## Finding ${i + 1}\n${f.summary || "(no summary)"}`),
+        ].join("\n\n");
+        try {
+            const synthesis = await runtime.complete(prompt, systemPrompt);
+            return { synthesis, citations: allCitations };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`reporter runtime failed: ${msg}`);
+        }
+    };
+}
+/**
+ * Bridge: run the deer-flow research pipeline.
+ *
+ * Requires (at minimum) a `searchProvider` for evidence gathering. With
+ * just the search provider the bridge still produces a complete report:
+ * the planner returns one sub-question (the user query), the researcher
+ * returns the raw hits as evidence, and the reporter concatenates the
+ * raw evidence. With a `runtime` ref the planner+reporter become
+ * LLM-driven and the researcher gains an evidence-summarisation step.
+ *
+ * When neither is supplied AND `forceFixture` is false, returns ok:false
+ * with reason "no search provider supplied". This is QB#3 — research
+ * without retrieval is hallucination.
+ */
+export async function runDeerFlowResearch(query, options = {}) {
+    if (typeof query !== "string" || query.trim().length === 0) {
+        return { ok: false, reason: "query must be a non-empty string" };
+    }
+    const maxSubQuestions = options.maxSubQuestions ?? 3;
+    if (!Number.isFinite(maxSubQuestions) || maxSubQuestions <= 0) {
+        return { ok: false, reason: "maxSubQuestions must be a positive integer" };
+    }
+    const useFixture = options.forceFixture === true || options.searchProvider === undefined;
+    if (useFixture && !options.forceFixture) {
+        return {
+            ok: false,
+            reason: "no search provider supplied. Pass `searchProvider` (a SearchProvider callback) or set `forceFixture:true` to run the deterministic placeholder pipeline.",
+        };
+    }
+    let pipeline;
+    if (options.forceFixture === true) {
+        pipeline = fixturePipeline();
+    }
+    else {
+        const searchProvider = options.searchProvider;
+        pipeline = {
+            planner: options.runtime
+                ? buildRuntimePlanner(options.runtime, maxSubQuestions)
+                : (q) => [
+                    {
+                        id: "subq-1",
+                        text: q.question,
+                        rationale: "no runtime planner; using original question",
+                    },
+                ],
+            researcher: buildResearcher(searchProvider, options.runtime),
+            reporter: buildReporter(options.runtime),
+        };
+    }
+    const researchQuery = {
+        question: query,
+        maxSubQuestions,
+    };
+    const outcome = await runResearch(researchQuery, pipeline);
+    return {
+        ok: true,
+        outcome,
+        mode: options.forceFixture === true ? "fixture" : "runtime",
+    };
+}
+async function loadGraphSnapshot(path) {
+    try {
+        const raw = await fsp.readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const entities = Array.isArray(parsed.entities) ? parsed.entities : [];
+        const edges = Array.isArray(parsed.edges) ? parsed.edges : [];
+        return {
+            entities: entities.filter((e) => typeof e === "object" &&
+                e !== null &&
+                typeof e.id === "string" &&
+                typeof e.type === "string"),
+            edges: edges.filter((e) => typeof e === "object" &&
+                e !== null &&
+                typeof e.from === "string" &&
+                typeof e.to === "string" &&
+                typeof e.relation === "string"),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function rehydrateStore(store, snapshot) {
+    for (const e of snapshot.entities)
+        store.addEntity(e);
+    for (const ed of snapshot.edges)
+        store.addEdge(ed);
+}
+function snapshotStore(store) {
+    const entities = store.getEntities();
+    const edges = [];
+    for (const e of entities) {
+        for (const out of store.getEdgesFrom(e.id))
+            edges.push(out);
+    }
+    return { entities, edges };
+}
+/**
+ * Bridge: ingest text into a mem0-style graph memory.
+ *
+ * Uses `createInMemoryGraphStore` by default (no persistence). When
+ * `persist:true` the store is rehydrated from + flushed back to
+ * `${WOTANN_HOME}/mem-graph.json`. Returns the extracted triples plus a
+ * 2-hop neighborhood walk for every subject as a stable read view.
+ */
+export async function ingestTextToMemGraph(text, options = {}) {
+    if (typeof text !== "string") {
+        return { ok: false, reason: "text must be a string" };
+    }
+    if (text.trim().length === 0) {
+        return {
+            ok: true,
+            triples: [],
+            entitiesAdded: 0,
+            edgesAdded: 0,
+            neighborhoods: [],
+            persisted: false,
+        };
+    }
+    const store = createInMemoryGraphStore();
+    const persist = options.persist === true;
+    const path = options.persistencePath ?? resolveWotannHomeSubdir("mem-graph.json");
+    if (persist) {
+        const snapshot = await loadGraphSnapshot(path);
+        if (snapshot)
+            rehydrateStore(store, snapshot);
+    }
+    const ingestOptions = options.turnId !== undefined && options.llm !== undefined
+        ? { turnId: options.turnId, llm: options.llm }
+        : options.turnId !== undefined
+            ? { turnId: options.turnId }
+            : options.llm !== undefined
+                ? { llm: options.llm }
+                : {};
+    const result = await ingestText(store, text, ingestOptions);
+    if (!result.ok) {
+        return { ok: false, reason: result.reason };
+    }
+    // Build 2-hop neighborhood for each subject. Deduplicate by entity id.
+    const seen = new Set();
+    const neighborhoods = [];
+    for (const t of result.triples) {
+        if (seen.has(t.subject.id))
+            continue;
+        seen.add(t.subject.id);
+        neighborhoods.push({
+            entityId: t.subject.id,
+            edges: neighborhood(store, t.subject.id, 2),
+        });
+    }
+    let persisted = false;
+    if (persist) {
+        try {
+            const out = snapshotStore(store);
+            const json = JSON.stringify(out, null, 2);
+            const parent = dirname(path);
+            await fsp.mkdir(parent, { recursive: true });
+            writeFileAtomic(path, json);
+            persisted = true;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, reason: `persist failed: ${msg}` };
+        }
+    }
+    return {
+        ok: true,
+        triples: result.triples,
+        entitiesAdded: result.entitiesAdded,
+        edgesAdded: result.edgesAdded,
+        neighborhoods,
+        persisted,
+    };
+}
+function buildBridgeTree(snapshot) {
+    let counter = 0;
+    const all = [];
+    function build(raw, parent, siblingIndex) {
+        const node = {
+            id: counter++,
+            tag: raw.tag,
+            classes: Array.isArray(raw.classes) ? [...raw.classes] : [],
+            text: typeof raw.text === "string" ? raw.text : "",
+            parent,
+            siblingIndex,
+            children: [],
+        };
+        all.push(node);
+        if (Array.isArray(raw.children)) {
+            raw.children.forEach((c, i) => {
+                node.children.push(build(c, node, i));
+            });
+        }
+        return node;
+    }
+    const root = build(snapshot.root, null, 0);
+    return { root, all };
+}
+/**
+ * Tiny CSS-shaped selector: supports `tag`, `.class`, `tag.class`, and
+ * descendant combinators ` ` (space). No pseudo-classes, no attribute
+ * selectors. Sufficient for the bridge's locate-by-fingerprint use case;
+ * stronger selectors are a future port-side change.
+ */
+function querySelectorAll(nodes, selector) {
+    const trimmed = selector.trim();
+    if (trimmed.length === 0)
+        return [];
+    const parts = trimmed.split(/\s+/);
+    function matchOne(part, node) {
+        // Split into tag + classes
+        const tagMatch = part.match(/^([a-zA-Z][a-zA-Z0-9-]*)?/);
+        const tag = tagMatch?.[1] ?? "";
+        const classes = part.match(/\.([a-zA-Z0-9_-]+)/g);
+        if (tag.length > 0 && node.tag !== tag)
+            return false;
+        if (classes) {
+            for (const c of classes) {
+                const className = c.slice(1);
+                if (!node.classes.includes(className))
+                    return false;
+            }
+        }
+        return true;
+    }
+    function isAncestor(ancestor, descendant) {
+        let p = descendant.parent;
+        while (p) {
+            if (p === ancestor)
+                return true;
+            p = p.parent;
+        }
+        return false;
+    }
+    // Match the last part directly, then walk back through earlier parts.
+    const lastPart = parts[parts.length - 1] ?? "";
+    const candidates = nodes.filter((n) => matchOne(lastPart, n));
+    if (parts.length === 1)
+        return candidates;
+    return candidates.filter((c) => {
+        let current = c;
+        for (let i = parts.length - 2; i >= 0; i--) {
+            const part = parts[i];
+            if (part === undefined)
+                return false;
+            // Walk up looking for an ancestor matching part[i].
+            let found = null;
+            let p = current?.parent ?? null;
+            while (p) {
+                if (matchOne(part, p)) {
+                    found = p;
+                    break;
+                }
+                p = p.parent;
+            }
+            if (!found)
+                return false;
+            current = found;
+        }
+        return true;
+    });
+}
+function buildAdapter(root, allNodes) {
+    return {
+        query: (selector) => querySelectorAll(allNodes, selector),
+        queryFrom: (rootNode, selector) => {
+            const subset = [];
+            function walk(n) {
+                subset.push(n);
+                for (const c of n.children)
+                    walk(c);
+            }
+            walk(rootNode);
+            return querySelectorAll(subset, selector);
+        },
+        getTag: (n) => n.tag,
+        getClasses: (n) => n.classes,
+        getText: (n) => n.text,
+        getParent: (n) => n.parent,
+        getSiblingIndex: (n) => n.siblingIndex,
+        walkAll: () => allNodes,
+    };
+}
+/**
+ * Bridge: adaptively locate a node by label within a DOM snapshot.
+ *
+ * The caller submits:
+ *   - a DomSnapshot (a JSON tree of nodes)
+ *   - a query label
+ *   - either:
+ *       * a `selector` string, in which case the bridge runs adaptiveLocate
+ *         (which saves a fingerprint AND returns the located node), OR
+ *       * just a label, in which case the bridge runs relocate against
+ *         a previously-saved fingerprint. Since the store is per-call,
+ *         the snapshot must include `seeds` to pre-populate the store.
+ *
+ * Returns the located node's tag, classes, and a text preview, along
+ * with the similarity score and whether the original selector was used.
+ *
+ * Per-call state: the FingerprintStore is created fresh inside this
+ * function (QB#7). For session-scoped fingerprints, a follow-up RPC
+ * surface can pass a long-lived store ref — that's deferred to the
+ * scrapling-adaptive port itself, not this bridge.
+ */
+export async function adaptiveLocateOnDom(domSnapshot, query, options = {}) {
+    if (!domSnapshot || typeof domSnapshot !== "object" || !domSnapshot.root) {
+        return { ok: false, reason: "domSnapshot must include a root node" };
+    }
+    if (!query || typeof query.label !== "string" || query.label.length === 0) {
+        return { ok: false, reason: "query.label must be a non-empty string" };
+    }
+    const { all } = buildBridgeTree(domSnapshot);
+    if (all.length === 0) {
+        return { ok: false, reason: "snapshot produced zero nodes" };
+    }
+    const root = all[0];
+    if (!root) {
+        return { ok: false, reason: "snapshot produced zero nodes" };
+    }
+    const adapter = buildAdapter(root, all);
+    const store = createInMemoryFingerprintStore();
+    // Pre-seed the store with any caller-supplied (label, selector) pairs.
+    if (domSnapshot.seeds) {
+        for (const seed of domSnapshot.seeds) {
+            const result = adaptiveLocate(adapter, store, seed.label, seed.selector, {});
+            if (!result.ok) {
+                // Seeds that miss don't kill the whole call — they just don't
+                // contribute fingerprints. We log the miss in the reason field
+                // only if the eventual locate fails.
+                void result;
+            }
+        }
+    }
+    const relocateOptions = options.minScore !== undefined ? { minScore: options.minScore } : {};
+    const result = query.selector
+        ? adaptiveLocate(adapter, store, query.label, query.selector, relocateOptions)
+        : (() => {
+            const saved = store.load(query.label);
+            if (!saved) {
+                return {
+                    ok: false,
+                    reason: `no selector supplied and no fingerprint saved under label "${query.label}". Provide a selector or pre-seed via domSnapshot.seeds.`,
+                };
+            }
+            return adaptiveLocate(adapter, store, query.label, saved.originalSelector, relocateOptions);
+        })();
+    if (!result.ok) {
+        return { ok: false, reason: result.reason };
+    }
+    const text = result.node.text;
+    return {
+        ok: true,
+        label: query.label,
+        node: {
+            tag: result.node.tag,
+            classes: result.node.classes,
+            textPreview: text.length > 80 ? `${text.slice(0, 77)}...` : text,
+        },
+        score: result.score,
+        viaOriginalSelector: result.viaOriginalSelector,
+    };
+}
+// ── Test-only exports (QB#14 real-code-path) ─────────────
+export const _testOnly = {
+    tryParseSubQuestions,
+    buildRuntimeConverse,
+    buildRuntimePlanner,
+    buildResearcher,
+    buildReporter,
+    buildBridgeTree,
+    buildAdapter,
+    querySelectorAll,
+    loadGraphSnapshot,
+    snapshotStore,
+};
+//# sourceMappingURL=ports-bridge.js.map