wotann 0.5.0 → 0.5.39

package/dist/intelligence/research-loops/strategies/recursive-decomposition.js

@@ -0,0 +1,187 @@
+/**
+ * Recursive Decomposition strategy — ported from LDR
+ * `advanced_search_system/strategies/recursive_decomposition_strategy.py`.
+ *
+ * The lead agent decides for the input query: "DECOMPOSE" or
+ * "SEARCH_DIRECTLY". On DECOMPOSE, it produces 2–MAX_SUBTOPICS subtasks
+ * and recursively analyzes each at depth+1. On SEARCH_DIRECTLY (or
+ * when MAX_RECURSION_DEPTH is reached), the strategy calls the
+ * injected search provider once and synthesizes a leaf finding.
+ *
+ * Final synthesis aggregates per-subtask findings into a single root
+ * finding while preserving the per-subtask citations on the deeper
+ * findings.
+ *
+ * The decomposer is INJECTABLE — tests use a deterministic stub.
+ * Production wires an LLM-backed planner. Recursion is bounded by
+ * MAX_RECURSION_DEPTH AND a global tool-call cap (MAX_TOOL_CALLS_PER_RUN)
+ * so even a pathological decomposer cannot run away.
+ *
+ * Source: github.com/LearningCircuit/local-deep-research
+ *
+ * Quality bars: QB#1, QB#2, QB#6, QB#7, QB#14.
+ */
+import { ResearchResultsCollector } from "../results-collector.js";
+import { MAX_RECURSION_DEPTH, MAX_SUBTOPICS, MAX_TOOL_CALLS_PER_RUN, clampMax, requireProvider, } from "./base-strategy.js";
+const STRATEGY_NAME = "recursive-decomposition";
+export class RecursiveDecompositionStrategy {
+    name = STRATEGY_NAME;
+    opts;
+    constructor(options = {}) {
+        this.opts = Object.freeze({
+            maxToolCalls: clampMax(options.maxToolCalls, MAX_TOOL_CALLS_PER_RUN, MAX_TOOL_CALLS_PER_RUN),
+            maxDepth: clampMax(options.maxDepth, MAX_RECURSION_DEPTH, MAX_RECURSION_DEPTH),
+            maxSubtopics: clampMax(options.maxSubtopics, MAX_SUBTOPICS, MAX_SUBTOPICS),
+            decomposer: options.decomposer,
+        });
+    }
+    async run(query, context) {
+        if (typeof query !== "string" || query.length === 0) {
+            throw new Error("recursive-decomposition: query must be non-empty string");
+        }
+        const noProvider = requireProvider(context, STRATEGY_NAME);
+        if (noProvider)
+            return Object.freeze({ ...noProvider, query });
+        const state = {
+            toolCalls: 0,
+            stopReason: "completed",
+            collector: new ResearchResultsCollector(),
+        };
+        const rootFinding = await this.analyze(query, 0, context, state);
+        return Object.freeze({
+            strategy: STRATEGY_NAME,
+            query,
+            findings: Object.freeze([rootFinding]),
+            toolCalls: state.toolCalls,
+            stopReason: state.stopReason,
+            ok: state.stopReason !== "provider-error",
+        });
+    }
+    /**
+     * Analyze a (sub)query at a given depth. Returns a single finding
+     * for this node — for decomposed nodes, the finding's content is
+     * the LLM-aggregated synthesis of child findings.
+     */
+    async analyze(query, depth, context, state) {
+        // Depth cap → direct search.
+        if (depth >= this.opts.maxDepth) {
+            if (state.stopReason === "completed")
+                state.stopReason = "max-depth";
+            return this.directSearch(query, depth, context, state);
+        }
+        if (state.toolCalls >= this.opts.maxToolCalls) {
+            state.stopReason = "max-tool-calls";
+            return Object.freeze({
+                question: query,
+                content: `[cap reached at depth ${depth}] ${query}`,
+                citations: Object.freeze([]),
+                depth,
+            });
+        }
+        // Decompose? Without a decomposer we fall straight through to search.
+        let decision = {
+            shouldDecompose: false,
+            subtasks: [],
+            reasoning: "no decomposer",
+        };
+        if (this.opts.decomposer) {
+            try {
+                decision = await this.opts.decomposer(query, depth);
+            }
+            catch {
+                decision = { shouldDecompose: false, subtasks: [], reasoning: "decomposer-error" };
+            }
+        }
+        if (!decision.shouldDecompose || decision.subtasks.length === 0) {
+            return this.directSearch(query, depth, context, state);
+        }
+        const subtasks = decision.subtasks.slice(0, this.opts.maxSubtopics);
+        const subFindings = [];
+        for (const sub of subtasks) {
+            if (state.toolCalls >= this.opts.maxToolCalls) {
+                state.stopReason = "max-tool-calls";
+                break;
+            }
+            const child = await this.analyze(sub, depth + 1, context, state);
+            subFindings.push(child);
+        }
+        const aggregatedContent = aggregate(query, decision, subFindings, depth);
+        const allCitations = subFindings.flatMap((f) => [...f.citations]);
+        return Object.freeze({
+            question: query,
+            content: aggregatedContent,
+            citations: Object.freeze(dedupeCitations(allCitations)),
+            depth,
+        });
+    }
+    async directSearch(query, depth, context, state) {
+        if (state.toolCalls >= this.opts.maxToolCalls) {
+            state.stopReason = "max-tool-calls";
+            return Object.freeze({
+                question: query,
+                content: `[cap reached at depth ${depth}] ${query}`,
+                citations: Object.freeze([]),
+                depth,
+            });
+        }
+        let hits;
+        try {
+            const out = await context.provider(query);
+            hits = Array.isArray(out) ? out : [];
+        }
+        catch {
+            state.stopReason = "provider-error";
+            return Object.freeze({
+                question: query,
+                content: `[provider-error] ${query}`,
+                citations: Object.freeze([]),
+                depth,
+            });
+        }
+        state.toolCalls += 1;
+        const startSize = state.collector.size();
+        state.collector.addResults(hits, `depth-${depth}`);
+        const newCitations = state.collector.citations().slice(startSize);
+        const summary = summarizeHits(query, hits);
+        return Object.freeze({
+            question: query,
+            content: summary,
+            citations: Object.freeze(newCitations),
+            depth,
+        });
+    }
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+function aggregate(query, decision, subFindings, depth) {
+    const lines = [];
+    lines.push(`# ${query} (depth ${depth})`);
+    lines.push(`Decomposed into ${subFindings.length} subtask(s): ${decision.reasoning}`);
+    for (let i = 0; i < subFindings.length; i++) {
+        const sf = subFindings[i];
+        if (!sf)
+            continue;
+        lines.push(`\n## Subtask ${i + 1}: ${sf.question}`);
+        lines.push(sf.content);
+    }
+    return lines.join("\n");
+}
+function summarizeHits(query, hits) {
+    if (hits.length === 0)
+        return `No results for: ${query}`;
+    const lines = [`### ${query}`];
+    for (const h of hits.slice(0, 8))
+        lines.push(`- ${h.title}: ${h.snippet}`);
+    return lines.join("\n");
+}
+function dedupeCitations(cits) {
+    const seen = new Set();
+    const out = [];
+    for (const c of cits) {
+        if (seen.has(c.index))
+            continue;
+        seen.add(c.index);
+        out.push(c);
+    }
+    return out;
+}
+//# sourceMappingURL=recursive-decomposition.js.map

package/dist/intelligence/research-loops/strategies/recursive-decomposition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursive-decomposition.js","sourceRoot":"","sources":["../../../../src/intelligence/research-loops/strategies/recursive-decomposition.ts"],"names":[],"mappings":"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"}

package/dist/intelligence/research-loops/strategy-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Strategy registry — names → strategy constructors.
+ *
+ * The registry exposes:
+ *   - RESEARCH_STRATEGIES: a frozen map of name → factory
+ *   - getStrategy(name): returns a fresh instance or null
+ *
+ * Strategies are constructed lazily so each call gets a fresh
+ * collector / counter (QB #7 per-call state — never share instances
+ * across runs).
+ *
+ * Wire-in to the existing /research skill is INTENTIONALLY out of
+ * scope for this commit; see the follow-up PR.
+ *
+ * Quality bars: QB#1 frozen registry, QB#7 fresh instance per call,
+ * QB#14 verified in strategy-registry.test.ts.
+ */
+import type { BaseResearchStrategy } from "./strategies/base-strategy.js";
+/** Factory keyed by strategy name. */
+export type StrategyFactory = () => BaseResearchStrategy;
+export declare const STRATEGY_NAMES: readonly ["langgraph-agent", "dual-confidence", "recursive-decomposition", "parallel-constrained"];
+export type StrategyName = (typeof STRATEGY_NAMES)[number];
+/**
+ * Frozen registry: name → factory. Each factory returns a fresh
+ * strategy instance so callers cannot accidentally share state
+ * across runs.
+ *
+ * `parallel-constrained` requires a `slots` config — the default
+ * factory builds it with a single slot equal to the query at run
+ * time; callers who want richer constraint coverage should construct
+ * `ParallelConstrainedStrategy` directly.
+ */
+export declare const RESEARCH_STRATEGIES: Readonly<Record<StrategyName, StrategyFactory>>;
+/**
+ * Return a fresh instance of the named strategy, or null if unknown.
+ * Never throws on unknown names — caller decides whether to surface
+ * the miss.
+ */
+export declare function getStrategy(name: string): BaseResearchStrategy | null;
+export declare function isKnownStrategy(name: string): name is StrategyName;
+/** List all available strategy names. Frozen at module load. */
+export declare function listStrategies(): readonly StrategyName[];
+//# sourceMappingURL=strategy-registry.d.ts.map

package/dist/intelligence/research-loops/strategy-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-registry.d.ts","sourceRoot":"","sources":["../../../src/intelligence/research-loops/strategy-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAM1E,sCAAsC;AACtC,MAAM,MAAM,eAAe,GAAG,MAAM,oBAAoB,CAAC;AAEzD,eAAO,MAAM,cAAc,oGAKhB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,CAK9E,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAIrE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,YAAY,CAElE;AAED,gEAAgE;AAChE,wBAAgB,cAAc,IAAI,SAAS,YAAY,EAAE,CAExD"}

package/dist/intelligence/research-loops/strategy-registry.js

@@ -0,0 +1,62 @@
+/**
+ * Strategy registry — names → strategy constructors.
+ *
+ * The registry exposes:
+ *   - RESEARCH_STRATEGIES: a frozen map of name → factory
+ *   - getStrategy(name): returns a fresh instance or null
+ *
+ * Strategies are constructed lazily so each call gets a fresh
+ * collector / counter (QB #7 per-call state — never share instances
+ * across runs).
+ *
+ * Wire-in to the existing /research skill is INTENTIONALLY out of
+ * scope for this commit; see the follow-up PR.
+ *
+ * Quality bars: QB#1 frozen registry, QB#7 fresh instance per call,
+ * QB#14 verified in strategy-registry.test.ts.
+ */
+import { LangGraphAgentStrategy } from "./strategies/langgraph-agent.js";
+import { DualConfidenceStrategy } from "./strategies/dual-confidence.js";
+import { RecursiveDecompositionStrategy } from "./strategies/recursive-decomposition.js";
+import { ParallelConstrainedStrategy } from "./strategies/parallel-constrained.js";
+export const STRATEGY_NAMES = Object.freeze([
+    "langgraph-agent",
+    "dual-confidence",
+    "recursive-decomposition",
+    "parallel-constrained",
+]);
+/**
+ * Frozen registry: name → factory. Each factory returns a fresh
+ * strategy instance so callers cannot accidentally share state
+ * across runs.
+ *
+ * `parallel-constrained` requires a `slots` config — the default
+ * factory builds it with a single slot equal to the query at run
+ * time; callers who want richer constraint coverage should construct
+ * `ParallelConstrainedStrategy` directly.
+ */
+export const RESEARCH_STRATEGIES = Object.freeze({
+    "langgraph-agent": () => new LangGraphAgentStrategy(),
+    "dual-confidence": () => new DualConfidenceStrategy(),
+    "recursive-decomposition": () => new RecursiveDecompositionStrategy(),
+    "parallel-constrained": () => new ParallelConstrainedStrategy({ slots: [{ query: "default" }] }),
+});
+/**
+ * Return a fresh instance of the named strategy, or null if unknown.
+ * Never throws on unknown names — caller decides whether to surface
+ * the miss.
+ */
+export function getStrategy(name) {
+    if (!isKnownStrategy(name))
+        return null;
+    const factory = RESEARCH_STRATEGIES[name];
+    return factory();
+}
+export function isKnownStrategy(name) {
+    return STRATEGY_NAMES.includes(name);
+}
+/** List all available strategy names. Frozen at module load. */
+export function listStrategies() {
+    return STRATEGY_NAMES;
+}
+//# sourceMappingURL=strategy-registry.js.map

package/dist/intelligence/research-loops/strategy-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-registry.js","sourceRoot":"","sources":["../../../src/intelligence/research-loops/strategy-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAKnF,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC;IAC1C,iBAAiB;IACjB,iBAAiB;IACjB,yBAAyB;IACzB,sBAAsB;CACd,CAAC,CAAC;AAIZ;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAoD,MAAM,CAAC,MAAM,CAAC;IAChG,iBAAiB,EAAE,GAAG,EAAE,CAAC,IAAI,sBAAsB,EAAE;IACrD,iBAAiB,EAAE,GAAG,EAAE,CAAC,IAAI,sBAAsB,EAAE;IACrD,yBAAyB,EAAE,GAAG,EAAE,CAAC,IAAI,8BAA8B,EAAE;IACrE,sBAAsB,EAAE,GAAG,EAAE,CAAC,IAAI,2BAA2B,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;CACjG,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,MAAM,OAAO,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,OAAO,EAAE,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,OAAQ,cAAoC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC9D,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,cAAc;IAC5B,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/intelligence/research-strategies.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Research strategies — dual-confidence, recursive-decomposition,
+ * iterDRAG. Ports the three patterns documented in
+ * LearningCircuit/local-deep-research.
+ *
+ * The strategies are wrappers around a caller-supplied `search` callback:
+ *
+ *   - dualConfidenceSearch(q)            — runs search twice with
+ *     a rephrased twin query, returns confidence ∈ [0,1] from source
+ *     overlap. Cheap (2 calls) + meaningful divergence signal.
+ *
+ *   - recursivelyDecompose(q, decompose) — recursively breaks a
+ *     question into atoms when the heuristic detects compound shape
+ *     ("and"/"or", semicolons, multi-clause). Each level uses the
+ *     caller-supplied `decompose` callback; the function itself only
+ *     decides *whether* to recurse.
+ *
+ *   - iterDrag(root, …)                  — Iterative
+ *     Decompose-Retrieve-Aggregate-Generate. Walks a question tree
+ *     to bounded depth, gathering hits at each node and aggregating
+ *     bottom-up. Designed for multi-hop questions.
+ *
+ * QUALITY BARS
+ *   - QB#1 No vendor bias — search/decompose/synthesize are callbacks.
+ *   - QB#3 Honest stub — every error path returns a structured error;
+ *     never fakes evidence.
+ *   - QB#7 Per-call state — every strategy allocates fresh state.
+ */
+export interface Hit {
+    readonly url: string;
+    readonly title?: string;
+    readonly snippet?: string;
+}
+export type SearchFn = (query: string) => Promise<readonly Hit[]>;
+export interface DualConfidenceOptions {
+    /** Optional twin query supplier. Defaults to {@link rephraseQuery}. */
+    readonly rephrase?: (query: string) => string;
+    /** Cap the number of hits per search before computing overlap. */
+    readonly hitsPerCall?: number;
+}
+export interface DualConfidenceResult {
+    /** Hits unique to the primary query. */
+    readonly primaryHits: readonly Hit[];
+    /** Hits unique to the rephrased twin query. */
+    readonly twinHits: readonly Hit[];
+    /** Hits that appeared in both passes (high signal). */
+    readonly overlap: readonly Hit[];
+    /** Jaccard overlap of URL sets, ∈ [0,1]. */
+    readonly confidence: number;
+    /** True when overlap is below the divergence threshold (0.3). */
+    readonly diverged: boolean;
+}
+/**
+ * Dual-confidence search. Runs the user's search callback twice — once
+ * with the original query, once with a rephrased twin — and reports
+ * how much the two result sets agree. High overlap → strong signal.
+ * Low overlap → caller should treat the answer as low-confidence and
+ * gather more evidence before synthesis.
+ */
+export declare function dualConfidenceSearch(query: string, search: SearchFn, opts?: DualConfidenceOptions): Promise<DualConfidenceResult>;
+/**
+ * Default rephraser. Three deterministic transforms applied in order:
+ *   1. If the query is a direct question ("How do X?"), reword as a
+ *      noun phrase ("definition of X", "best practices for X").
+ *   2. Strip filler ("how can I", "tell me about", "I want to know").
+ *   3. Append the query's main keyword to the front for emphasis.
+ *
+ * No LLM call — keeps dual-confidence cheap.
+ */
+export declare function rephraseQuery(query: string): string;
+export interface DecomposedQuestion {
+    readonly text: string;
+    readonly depth: number;
+    readonly children: readonly DecomposedQuestion[];
+}
+export interface DecomposeOptions {
+    /** Max recursion depth. Default 3. */
+    readonly maxDepth?: number;
+    /** Override the heuristic that decides if a question is compound. */
+    readonly isCompound?: (q: string) => boolean;
+}
+export type DecomposeFn = (question: string) => Promise<readonly string[]>;
+/**
+ * Recursively decompose a question into atoms. The provided
+ * `decompose` callback is asked to break the input into immediate
+ * sub-questions; we then call it again on each sub-question that
+ * still looks compound.
+ *
+ * Stops when:
+ *   - the heuristic flags the question as atomic, OR
+ *   - depth ≥ maxDepth, OR
+ *   - decompose() returns ≤ 1 child (no progress).
+ */
+export declare function recursivelyDecompose(question: string, decompose: DecomposeFn, opts?: DecomposeOptions): Promise<DecomposedQuestion>;
+/**
+ * Cheap compound-shape heuristic. A question is "compound" when it:
+ *   - contains a connective (" and ", " or ", semicolon, "; "), OR
+ *   - has multiple distinct interrogatives ("what … and how …"), OR
+ *   - is long enough (≥ 25 words) to likely span multiple ideas.
+ */
+export declare function defaultCompoundCheck(question: string): boolean;
+export interface IterDragNode {
+    readonly question: string;
+    readonly depth: number;
+    readonly hits: readonly Hit[];
+    readonly children: readonly IterDragNode[];
+    /** Aggregated answer at this node, populated bottom-up. */
+    readonly aggregated: string;
+}
+export interface IterDragOptions {
+    readonly maxDepth?: number;
+    /** Hits per node to retain after dedup. Default 5. */
+    readonly hitsPerNode?: number;
+    /** Optional aggregator for combining child answers + hits into a node answer. */
+    readonly aggregate?: (question: string, hits: readonly Hit[], childAnswers: readonly string[]) => string | Promise<string>;
+}
+/**
+ * Iterative Decompose-Retrieve-Aggregate-Generate. Depth-bounded tree
+ * walk: at each node, call `search` for evidence, recurse via
+ * `decompose` while the question is compound and we have budget, then
+ * roll up answers bottom-up using `aggregate`.
+ *
+ * The default aggregator is a concatenation of child answers + the
+ * current node's hit titles — sufficient to drive a final synthesize()
+ * call without the strategy module hard-coding LLM behaviour.
+ */
+export declare function iterDrag(rootQuestion: string, search: SearchFn, decompose: DecomposeFn, opts?: IterDragOptions): Promise<IterDragNode>;
+/**
+ * Walk an IterDragNode tree and yield every node depth-first. Useful
+ * for callers that want to render the tree or extract evidence flatly.
+ */
+export declare function iterDragNodes(root: IterDragNode): Generator<IterDragNode, void, undefined>;
+//# sourceMappingURL=research-strategies.d.ts.map

package/dist/intelligence/research-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-strategies.d.ts","sourceRoot":"","sources":["../../src/intelligence/research-strategies.ts"],"names":[],"mappings":"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"}

package/dist/intelligence/research-strategies.js

@@ -0,0 +1,204 @@
+/**
+ * Research strategies — dual-confidence, recursive-decomposition,
+ * iterDRAG. Ports the three patterns documented in
+ * LearningCircuit/local-deep-research.
+ *
+ * The strategies are wrappers around a caller-supplied `search` callback:
+ *
+ *   - dualConfidenceSearch(q)            — runs search twice with
+ *     a rephrased twin query, returns confidence ∈ [0,1] from source
+ *     overlap. Cheap (2 calls) + meaningful divergence signal.
+ *
+ *   - recursivelyDecompose(q, decompose) — recursively breaks a
+ *     question into atoms when the heuristic detects compound shape
+ *     ("and"/"or", semicolons, multi-clause). Each level uses the
+ *     caller-supplied `decompose` callback; the function itself only
+ *     decides *whether* to recurse.
+ *
+ *   - iterDrag(root, …)                  — Iterative
+ *     Decompose-Retrieve-Aggregate-Generate. Walks a question tree
+ *     to bounded depth, gathering hits at each node and aggregating
+ *     bottom-up. Designed for multi-hop questions.
+ *
+ * QUALITY BARS
+ *   - QB#1 No vendor bias — search/decompose/synthesize are callbacks.
+ *   - QB#3 Honest stub — every error path returns a structured error;
+ *     never fakes evidence.
+ *   - QB#7 Per-call state — every strategy allocates fresh state.
+ */
+const DIVERGENCE_THRESHOLD = 0.3;
+/**
+ * Dual-confidence search. Runs the user's search callback twice — once
+ * with the original query, once with a rephrased twin — and reports
+ * how much the two result sets agree. High overlap → strong signal.
+ * Low overlap → caller should treat the answer as low-confidence and
+ * gather more evidence before synthesis.
+ */
+export async function dualConfidenceSearch(query, search, opts = {}) {
+    const cap = typeof opts.hitsPerCall === "number" ? opts.hitsPerCall : Infinity;
+    const rephrase = opts.rephrase ?? rephraseQuery;
+    const twinQuery = rephrase(query);
+    const [primaryHits, twinHits] = await Promise.all([
+        search(query).then((h) => h.slice(0, cap)),
+        search(twinQuery).then((h) => h.slice(0, cap)),
+    ]);
+    const primaryUrls = new Set(primaryHits.map((h) => h.url));
+    const twinUrls = new Set(twinHits.map((h) => h.url));
+    const overlap = [];
+    for (const h of primaryHits) {
+        if (twinUrls.has(h.url))
+            overlap.push(h);
+    }
+    const onlyPrimary = primaryHits.filter((h) => !twinUrls.has(h.url));
+    const onlyTwin = twinHits.filter((h) => !primaryUrls.has(h.url));
+    const unionSize = primaryUrls.size + twinUrls.size - overlap.length;
+    const confidence = unionSize === 0 ? 0 : overlap.length / unionSize;
+    return {
+        primaryHits: Object.freeze(onlyPrimary),
+        twinHits: Object.freeze(onlyTwin),
+        overlap: Object.freeze(overlap),
+        confidence,
+        diverged: confidence < DIVERGENCE_THRESHOLD,
+    };
+}
+/**
+ * Default rephraser. Three deterministic transforms applied in order:
+ *   1. If the query is a direct question ("How do X?"), reword as a
+ *      noun phrase ("definition of X", "best practices for X").
+ *   2. Strip filler ("how can I", "tell me about", "I want to know").
+ *   3. Append the query's main keyword to the front for emphasis.
+ *
+ * No LLM call — keeps dual-confidence cheap.
+ */
+export function rephraseQuery(query) {
+    let q = query.trim();
+    const lower = q.toLowerCase();
+    if (lower.startsWith("how do ") || lower.startsWith("how to ")) {
+        q = q.replace(/^[Hh]ow\s+(do|to)\s+/, "best practices for ");
+    }
+    else if (lower.startsWith("what is ") || lower.startsWith("what are ")) {
+        q = q.replace(/^[Ww]hat\s+(is|are)\s+/, "definition of ");
+    }
+    else if (lower.startsWith("why ")) {
+        q = q.replace(/^[Ww]hy\s+/, "reasons ");
+    }
+    q = q.replace(/^(how can i|tell me about|i want to know|please tell me)\s+/i, "");
+    return q.trim();
+}
+/**
+ * Recursively decompose a question into atoms. The provided
+ * `decompose` callback is asked to break the input into immediate
+ * sub-questions; we then call it again on each sub-question that
+ * still looks compound.
+ *
+ * Stops when:
+ *   - the heuristic flags the question as atomic, OR
+ *   - depth ≥ maxDepth, OR
+ *   - decompose() returns ≤ 1 child (no progress).
+ */
+export async function recursivelyDecompose(question, decompose, opts = {}) {
+    const maxDepth = opts.maxDepth ?? 3;
+    const isCompound = opts.isCompound ?? defaultCompoundCheck;
+    return await walk(question, 0, decompose, maxDepth, isCompound);
+}
+async function walk(text, depth, decompose, maxDepth, isCompound) {
+    if (depth >= maxDepth || !isCompound(text)) {
+        return { text, depth, children: Object.freeze([]) };
+    }
+    const children = await decompose(text);
+    if (children.length <= 1) {
+        return { text, depth, children: Object.freeze([]) };
+    }
+    const recursed = await Promise.all(children.map((c) => walk(c, depth + 1, decompose, maxDepth, isCompound)));
+    return { text, depth, children: Object.freeze(recursed) };
+}
+/**
+ * Cheap compound-shape heuristic. A question is "compound" when it:
+ *   - contains a connective (" and ", " or ", semicolon, "; "), OR
+ *   - has multiple distinct interrogatives ("what … and how …"), OR
+ *   - is long enough (≥ 25 words) to likely span multiple ideas.
+ */
+export function defaultCompoundCheck(question) {
+    const text = question.trim();
+    if (text.length === 0)
+        return false;
+    const lower = text.toLowerCase();
+    if (/\band\b|\bor\b|;|\bvs\.?\b|, /.test(lower))
+        return true;
+    const interrogatives = (lower.match(/\b(how|why|what|when|where|who|which)\b/g) ?? []).length;
+    if (interrogatives >= 2)
+        return true;
+    const wordCount = text.split(/\s+/).filter(Boolean).length;
+    return wordCount >= 25;
+}
+/**
+ * Iterative Decompose-Retrieve-Aggregate-Generate. Depth-bounded tree
+ * walk: at each node, call `search` for evidence, recurse via
+ * `decompose` while the question is compound and we have budget, then
+ * roll up answers bottom-up using `aggregate`.
+ *
+ * The default aggregator is a concatenation of child answers + the
+ * current node's hit titles — sufficient to drive a final synthesize()
+ * call without the strategy module hard-coding LLM behaviour.
+ */
+export async function iterDrag(rootQuestion, search, decompose, opts = {}) {
+    const maxDepth = opts.maxDepth ?? 2;
+    const hitsPerNode = opts.hitsPerNode ?? 5;
+    const aggregate = opts.aggregate ?? defaultAggregator;
+    return await iterDragWalk(rootQuestion, 0, maxDepth, hitsPerNode, search, decompose, aggregate);
+}
+async function iterDragWalk(question, depth, maxDepth, hitsPerNode, search, decompose, aggregate) {
+    const allHits = await search(question);
+    const dedup = dedupeHitsByUrl(allHits).slice(0, hitsPerNode);
+    let children = [];
+    if (depth < maxDepth && defaultCompoundCheck(question)) {
+        const subQuestions = await decompose(question);
+        if (subQuestions.length > 1) {
+            children = await Promise.all(subQuestions.map((sq) => iterDragWalk(sq, depth + 1, maxDepth, hitsPerNode, search, decompose, aggregate)));
+        }
+    }
+    const childAnswers = children.map((c) => c.aggregated).filter((a) => a.length > 0);
+    const aggregated = await Promise.resolve(aggregate(question, dedup, childAnswers));
+    return {
+        question,
+        depth,
+        hits: Object.freeze(dedup),
+        children: Object.freeze(children),
+        aggregated,
+    };
+}
+function defaultAggregator(question, hits, childAnswers) {
+    const lines = [`Q: ${question}`];
+    if (childAnswers.length > 0) {
+        lines.push("Sub-answers:");
+        for (const a of childAnswers)
+            lines.push(`  - ${a.replace(/\n/g, " ").slice(0, 200)}`);
+    }
+    if (hits.length > 0) {
+        lines.push("Evidence:");
+        for (const h of hits)
+            lines.push(`  - ${h.title ?? h.url} (${h.url})`);
+    }
+    return lines.join("\n");
+}
+function dedupeHitsByUrl(hits) {
+    const seen = new Set();
+    const out = [];
+    for (const h of hits) {
+        if (!h.url || seen.has(h.url))
+            continue;
+        seen.add(h.url);
+        out.push(h);
+    }
+    return out;
+}
+/**
+ * Walk an IterDragNode tree and yield every node depth-first. Useful
+ * for callers that want to render the tree or extract evidence flatly.
+ */
+export function* iterDragNodes(root) {
+    yield root;
+    for (const c of root.children)
+        yield* iterDragNodes(c);
+}
+//# sourceMappingURL=research-strategies.js.map