wotann 0.5.0 → 0.5.39

package/dist/intelligence/research-loops/results-log.js

@@ -0,0 +1,178 @@
+/**
+ * results-log — Append-only TSV log for autoresearch loop results.
+ *
+ * Port of the `results.tsv` pattern from karpathy/autoresearch. Each
+ * line is one experimental run's outcome. The format is intentionally
+ * simple — six tab-separated columns, no header line that changes,
+ * grep-friendly, append-only — so the loop can write fast and humans
+ * can sed/awk it without parsing.
+ *
+ * Why TSV (not JSONL):
+ *   - karpathy's pattern: human-readable in `cat`, sortable by column
+ *     in `sort -k2 -n`, diffable in plain `diff`.
+ *   - JSON parsers can break on a malformed line; TSV with a single
+ *     column count is robustly recoverable.
+ *   - The simplicity-criterion gate (kept|discarded) reads as a single
+ *     column, so `awk -F'\t' '$5=="kept"'` is the report query.
+ *
+ * Why append-only:
+ *   - History is the artifact. Rewrites lose the "what we tried but
+ *     discarded" record that's the whole point of autopilot loops.
+ *   - Concurrent writers can append without coordinating; readers tail.
+ *
+ * Quality bars:
+ *   - QB#1 immutable: ResultRow is readonly; serializer never mutates
+ *   - QB#3 honest: parse returns ok:false for malformed lines instead
+ *     of throwing or silently dropping data
+ *   - QB#7 stateless: no module-level state; file path passed by caller
+ *   - QB#11 sibling-site: this is the runtime caller for the
+ *     "simplicity criterion" gate that budgeted-research.ts already
+ *     references in its docstring (per the comp-research audit)
+ */
+import { promises as fs } from "node:fs";
+import { dirname } from "node:path";
+// ── Encoding ─────────────────────────────────────────────────────────
+const COLUMN_COUNT = 6;
+const COLUMN_DELIMITER = "\t";
+const ROW_DELIMITER = "\n";
+/**
+ * Sanitize a string field — strips tab + newline (the delimiters) so a
+ * malicious description can't break the column count.
+ */
+function sanitize(s) {
+    return s.replace(/[\t\r\n]/g, " ").trim();
+}
+/**
+ * Serialize a single row to a TSV line (no trailing newline; caller
+ * decides how to join). Pure: never throws on valid input.
+ */
+export function serializeRow(row) {
+    const cols = [
+        sanitize(row.timestamp),
+        sanitize(row.runId),
+        sanitize(row.objective),
+        Number.isFinite(row.metric) ? row.metric.toString() : "NaN",
+        row.status,
+        sanitize(row.description),
+    ];
+    return cols.join(COLUMN_DELIMITER);
+}
+/**
+ * Parse a TSV line back into a row. Returns ok:false on malformed input
+ * — never throws so a single bad line can't crash a tail-reader.
+ */
+export function parseRow(line) {
+    if (line.length === 0 || line.startsWith("#")) {
+        return { ok: false, error: "empty or comment line" };
+    }
+    const cols = line.split(COLUMN_DELIMITER);
+    if (cols.length !== COLUMN_COUNT) {
+        return { ok: false, error: `expected ${COLUMN_COUNT} columns, got ${cols.length}` };
+    }
+    const [timestamp, runId, objective, metricStr, statusStr, description] = cols;
+    const metric = Number.parseFloat(metricStr);
+    if (!Number.isFinite(metric)) {
+        return { ok: false, error: `metric "${metricStr}" is not a finite number` };
+    }
+    if (!isStatus(statusStr)) {
+        return { ok: false, error: `status "${statusStr}" is not a known ResultStatus` };
+    }
+    return {
+        ok: true,
+        row: Object.freeze({
+            timestamp,
+            runId,
+            objective,
+            metric,
+            status: statusStr,
+            description,
+        }),
+    };
+}
+function isStatus(s) {
+    return s === "kept" || s === "discarded" || s === "crashed" || s === "skipped";
+}
+// ── File-level operations (caller-controlled side effects) ───────────
+/**
+ * Append one row to the log file. Creates the parent dir if missing.
+ * Uses an O_APPEND-style write so concurrent appenders do not interleave
+ * partial lines (Node's `appendFile` translates to O_APPEND on POSIX).
+ */
+export async function appendRow(filePath, row) {
+    await fs.mkdir(dirname(filePath), { recursive: true });
+    const line = serializeRow(row) + ROW_DELIMITER;
+    await fs.appendFile(filePath, line, { encoding: "utf8" });
+}
+/**
+ * Read all parseable rows from a log file. Malformed lines are
+ * skipped and reported in `errors`. Caller decides whether to surface
+ * the errors or treat the log as a best-effort source.
+ */
+export async function readRows(filePath) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { rows: [], errors: [] };
+        }
+        throw err;
+    }
+    const rows = [];
+    const errors = [];
+    const lines = raw.split(ROW_DELIMITER);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line === undefined || line === "")
+            continue;
+        const r = parseRow(line);
+        if (r.ok && r.row) {
+            rows.push(r.row);
+        }
+        else {
+            errors.push(`line ${i + 1}: ${r.error ?? "unknown"}`);
+        }
+    }
+    return {
+        rows: Object.freeze(rows),
+        errors: Object.freeze(errors),
+    };
+}
+// ── Simplicity-criterion gate ────────────────────────────────────────
+/**
+ * Karpathy's gate: when two runs achieve the same metric, prefer the
+ * SIMPLER one (lower description length, or earlier timestamp as
+ * tiebreaker). Returns the row that should be kept; the other should
+ * be marked `status: "discarded"`.
+ *
+ * Pure: takes two rows and returns the keeper.
+ */
+export function applySimplicityCriterion(a, b) {
+    if (a.metric !== b.metric) {
+        // Higher metric wins (assume "more is better"). Callers wanting
+        // "less is better" should negate the metric upstream.
+        return a.metric > b.metric ? a : b;
+    }
+    if (a.description.length !== b.description.length) {
+        return a.description.length < b.description.length ? a : b;
+    }
+    // Tiebreak: earlier wins.
+    return a.timestamp <= b.timestamp ? a : b;
+}
+/**
+ * Apply the simplicity criterion across a full results set, returning
+ * one keeper per `objective`. Useful for compacting a long log into a
+ * "best run per goal" summary.
+ */
+export function bestRunPerObjective(rows) {
+    const byObjective = new Map();
+    for (const row of rows) {
+        if (row.status === "crashed" || row.status === "skipped")
+            continue;
+        const incumbent = byObjective.get(row.objective);
+        byObjective.set(row.objective, incumbent ? applySimplicityCriterion(incumbent, row) : row);
+    }
+    return Object.freeze([...byObjective.values()]);
+}
+//# sourceMappingURL=results-log.js.map

package/dist/intelligence/research-loops/results-log.js.map

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

package/dist/intelligence/research-loops/strategies/base-strategy.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Base research strategy contract — ported from
+ * LearningCircuit/local-deep-research `advanced_search_system/strategies/base_strategy.py`.
+ *
+ * Defines the common interface that every strategy in this directory
+ * implements. Strategies are constructed with an INJECTABLE search
+ * provider so the test harness can prove the contract with a stub
+ * (QB #2 honest stubs / QB #11 sibling-site composition).
+ *
+ * Source: github.com/LearningCircuit/local-deep-research
+ * Strategies ported in this batch:
+ *   - langgraph-agent     parallel subagents + shared collector
+ *   - dual-confidence     high/medium/rejected pools
+ *   - recursive-decomposition  hierarchical subtask fan-out
+ *   - parallel-constrained  parallel branches under a shared budget
+ *
+ * Quality bars:
+ *   QB #1   immutable — every result is Object.freeze'd
+ *   QB #2   injectable provider — strategies don't bake a backend
+ *   QB #6   honest stubs — missing provider yields stop="no-provider"
+ *   QB #7   per-call state — no module globals
+ *   QB #14  verification — covered in tests/.../strategies/*.test.ts
+ *   QB #19  no zombie instances — every strategy is exercised in tests
+ *
+ * The 50-iteration GraphRecursionError cap from LDR's langgraph_agent is
+ * shared as MAX_TOOL_CALLS_PER_RUN here so no strategy ships a runaway
+ * loop. Subclasses MAY lower it but MUST NOT raise it without an audit.
+ */
+/**
+ * Hard ceiling on tool calls / search invocations per strategy run.
+ * Mirrors LDR's `DEFAULT_MAX_ITERATIONS = 50` from langgraph_agent_strategy.py.
+ * Strategies that loop MUST honor this — even if their per-step caller
+ * asks for more, the runner clamps to this value.
+ */
+export declare const MAX_TOOL_CALLS_PER_RUN = 50;
+/** Hard ceiling on recursion depth — protects recursive-decomposition. */
+export declare const MAX_RECURSION_DEPTH = 5;
+/** Hard ceiling on fan-out width for parallel/decomposition strategies. */
+export declare const MAX_SUBTOPICS = 8;
+/** Maximum number of subagents we'll launch concurrently. */
+export declare const MAX_SUBAGENT_WORKERS = 4;
+/** One search hit returned by the injected provider. */
+export interface SearchHit {
+    readonly title: string;
+    readonly url: string;
+    readonly snippet: string;
+    /** Optional engine identifier for citation grouping. */
+    readonly sourceEngine?: string;
+}
+/**
+ * Injected search backend. Returns an arbitrary number of hits for a
+ * single query. Tests inject a stub; production wires DuckDuckGo /
+ * SearXNG / DeepResearch via deep-research.ts.
+ *
+ * Why a callback (not a class)? Strategies should compose with any
+ * backend the host wires, including in-memory stubs. The contract is
+ * the smallest thing it can be.
+ */
+export type SearchProvider = (query: string) => Promise<readonly SearchHit[]>;
+/** Confidence bucket — used by dual-confidence + others. */
+export type ConfidenceLevel = "high" | "medium" | "rejected";
+/** One citation backed by a numbered index. Indices come from the collector. */
+export interface ResearchCitation {
+    readonly index: number;
+    readonly hit: SearchHit;
+    /** Confidence label for dual-confidence; "high" by default. */
+    readonly confidence: ConfidenceLevel;
+}
+/** One unit of synthesized output from a strategy. */
+export interface ResearchFinding {
+    readonly question: string;
+    readonly content: string;
+    readonly citations: readonly ResearchCitation[];
+    /** For decomposition strategies — depth at which this finding was produced. */
+    readonly depth?: number;
+}
+export interface ResearchContext {
+    readonly provider: SearchProvider;
+    /** Wall-clock now-ms; injectable for deterministic tests. */
+    readonly now?: () => number;
+    /** Optional strategy-specific overrides (max iters, depth, etc.). */
+    readonly overrides?: Readonly<Record<string, number>>;
+}
+export type StrategyStopReason = "completed" | "max-tool-calls" | "max-depth" | "no-provider" | "provider-error" | "no-results";
+export interface ResearchResult {
+    readonly strategy: string;
+    readonly query: string;
+    readonly findings: readonly ResearchFinding[];
+    readonly toolCalls: number;
+    readonly stopReason: StrategyStopReason;
+    readonly ok: boolean;
+}
+/**
+ * Every strategy implements `run(query, context)`. The runner is a
+ * plain async function, not a class, so it composes naturally with
+ * the existing helpers in `research-loops/` (budgeted-research, etc.).
+ *
+ * Implementations MUST:
+ *   1. Honor MAX_TOOL_CALLS_PER_RUN (or a lower per-strategy cap).
+ *   2. Return findings even when the cap fires (never empty hands).
+ *   3. Return `ok=false` + a meaningful stopReason on real failure.
+ *   4. Set `strategy` to a stable, kebab-case identifier.
+ */
+export interface BaseResearchStrategy {
+    readonly name: string;
+    run(query: string, context: ResearchContext): Promise<ResearchResult>;
+}
+export declare function requireProvider(context: ResearchContext, strategy: string): ResearchResult | null;
+export declare function clampMax(value: number | undefined, cap: number, fallback: number): number;
+export declare function emptyResult(strategy: string, query: string, reason: StrategyStopReason): ResearchResult;
+//# sourceMappingURL=base-strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.d.ts","sourceRoot":"","sources":["../../../../src/intelligence/research-loops/strategies/base-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,2EAA2E;AAC3E,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,6DAA6D;AAC7D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAItC,wDAAwD;AACxD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,SAAS,EAAE,CAAC,CAAC;AAI9E,4DAA4D;AAC5D,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7D,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;CACtC;AAED,sDAAsD;AACtD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAChD,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAID,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,qEAAqE;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,MAAM,kBAAkB,GAC1B,WAAW,GACX,gBAAgB,GAChB,WAAW,GACX,aAAa,GACb,gBAAgB,GAChB,YAAY,CAAC;AAEjB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;CACtB;AAID;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACvE;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAYjG;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzF;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,kBAAkB,GACzB,cAAc,CAShB"}

package/dist/intelligence/research-loops/strategies/base-strategy.js

@@ -0,0 +1,72 @@
+/**
+ * Base research strategy contract — ported from
+ * LearningCircuit/local-deep-research `advanced_search_system/strategies/base_strategy.py`.
+ *
+ * Defines the common interface that every strategy in this directory
+ * implements. Strategies are constructed with an INJECTABLE search
+ * provider so the test harness can prove the contract with a stub
+ * (QB #2 honest stubs / QB #11 sibling-site composition).
+ *
+ * Source: github.com/LearningCircuit/local-deep-research
+ * Strategies ported in this batch:
+ *   - langgraph-agent     parallel subagents + shared collector
+ *   - dual-confidence     high/medium/rejected pools
+ *   - recursive-decomposition  hierarchical subtask fan-out
+ *   - parallel-constrained  parallel branches under a shared budget
+ *
+ * Quality bars:
+ *   QB #1   immutable — every result is Object.freeze'd
+ *   QB #2   injectable provider — strategies don't bake a backend
+ *   QB #6   honest stubs — missing provider yields stop="no-provider"
+ *   QB #7   per-call state — no module globals
+ *   QB #14  verification — covered in tests/.../strategies/*.test.ts
+ *   QB #19  no zombie instances — every strategy is exercised in tests
+ *
+ * The 50-iteration GraphRecursionError cap from LDR's langgraph_agent is
+ * shared as MAX_TOOL_CALLS_PER_RUN here so no strategy ships a runaway
+ * loop. Subclasses MAY lower it but MUST NOT raise it without an audit.
+ */
+// ── Shared constants ─────────────────────────────────────────────────
+/**
+ * Hard ceiling on tool calls / search invocations per strategy run.
+ * Mirrors LDR's `DEFAULT_MAX_ITERATIONS = 50` from langgraph_agent_strategy.py.
+ * Strategies that loop MUST honor this — even if their per-step caller
+ * asks for more, the runner clamps to this value.
+ */
+export const MAX_TOOL_CALLS_PER_RUN = 50;
+/** Hard ceiling on recursion depth — protects recursive-decomposition. */
+export const MAX_RECURSION_DEPTH = 5;
+/** Hard ceiling on fan-out width for parallel/decomposition strategies. */
+export const MAX_SUBTOPICS = 8;
+/** Maximum number of subagents we'll launch concurrently. */
+export const MAX_SUBAGENT_WORKERS = 4;
+// ── Shared validation helpers ───────────────────────────────────────
+export function requireProvider(context, strategy) {
+    if (typeof context.provider !== "function") {
+        return Object.freeze({
+            strategy,
+            query: "",
+            findings: Object.freeze([]),
+            toolCalls: 0,
+            stopReason: "no-provider",
+            ok: false,
+        });
+    }
+    return null;
+}
+export function clampMax(value, cap, fallback) {
+    if (value === undefined || !Number.isFinite(value) || value <= 0)
+        return Math.min(fallback, cap);
+    return Math.min(Math.floor(value), cap);
+}
+export function emptyResult(strategy, query, reason) {
+    return Object.freeze({
+        strategy,
+        query,
+        findings: Object.freeze([]),
+        toolCalls: 0,
+        stopReason: reason,
+        ok: false,
+    });
+}
+//# sourceMappingURL=base-strategy.js.map

package/dist/intelligence/research-loops/strategies/base-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.js","sourceRoot":"","sources":["../../../../src/intelligence/research-loops/strategies/base-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wEAAwE;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAErC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAE/B,6DAA6D;AAC7D,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AA2FtC,uEAAuE;AAEvE,MAAM,UAAU,eAAe,CAAC,OAAwB,EAAE,QAAgB;IACxE,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QAC3C,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,QAAQ;YACR,KAAK,EAAE,EAAE;YACT,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAoB,EAAE,CAAC;YAC9C,SAAS,EAAE,CAAC;YACZ,UAAU,EAAE,aAAsB;YAClC,EAAE,EAAE,KAAK;SACV,CAAC,CAAC;IACL,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,KAAyB,EAAE,GAAW,EAAE,QAAgB;IAC/E,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IACjG,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,WAAW,CACzB,QAAgB,EAChB,KAAa,EACb,MAA0B;IAE1B,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,QAAQ;QACR,KAAK;QACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAoB,EAAE,CAAC;QAC9C,SAAS,EAAE,CAAC;QACZ,UAAU,EAAE,MAAM;QAClB,EAAE,EAAE,KAAK;KACV,CAAC,CAAC;AACL,CAAC"}

package/dist/intelligence/research-loops/strategies/dual-confidence.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Dual-Confidence with Rejection strategy — ported from LDR
+ * `advanced_search_system/strategies/dual_confidence_with_rejection.py`
+ * (and its parent `dual_confidence_strategy.py`).
+ *
+ * For each search hit, the strategy scores POSITIVE evidence (does the
+ * hit support the query?) and NEGATIVE evidence (does it actively
+ * contradict the query?). Hits are bucketed into three pools:
+ *   - high     pos ≥ HIGH_POSITIVE         and neg ≤ MAX_NEGATIVE_FOR_HIGH
+ *   - medium   pos ≥ MEDIUM_POSITIVE       and neg ≤ MAX_NEGATIVE_FOR_MEDIUM
+ *   - rejected anything else (logged but excluded from final answer)
+ *
+ * The "with rejection" variant adds an EARLY-REJECTION shortcut: if a
+ * hit's average negative > REJECTION_NEGATIVE_THRESHOLD, it's dropped
+ * before scoring positive evidence (LDR's `_evaluate_candidate_immediately`
+ * logic). This saves provider tokens.
+ *
+ * The confidence scorer is INJECTABLE — tests provide deterministic
+ * scores; production wires an LLM-backed judge. A missing scorer
+ * yields a single fixture finding with stop="no-provider" semantics.
+ *
+ * Source: github.com/LearningCircuit/local-deep-research
+ *
+ * Quality bars: QB#1, QB#2, QB#6, QB#7, QB#14.
+ */
+import { type BaseResearchStrategy, type ResearchContext, type ResearchCitation, type ResearchResult, type SearchHit } from "./base-strategy.js";
+/** Per-hit score returned by the injectable judge. */
+export interface DualConfidenceScore {
+    /** Confidence that the hit SUPPORTS the query. In [0,1]. */
+    readonly positive: number;
+    /** Confidence that the hit CONTRADICTS the query. In [0,1]. */
+    readonly negative: number;
+}
+export type ConfidenceScorer = (query: string, hit: SearchHit) => Promise<DualConfidenceScore>;
+export interface DualConfidenceOptions {
+    readonly scorer?: ConfidenceScorer;
+    readonly maxToolCalls?: number;
+    /** Min positive evidence to bucket as "high". Default 0.7. */
+    readonly highPositive?: number;
+    /** Max negative evidence allowed in the "high" bucket. Default 0.1. */
+    readonly maxNegativeForHigh?: number;
+    /** Min positive evidence to bucket as "medium". Default 0.4. */
+    readonly mediumPositive?: number;
+    /** Max negative evidence allowed in the "medium" bucket. Default 0.3. */
+    readonly maxNegativeForMedium?: number;
+    /** Negative threshold for early rejection (skips positive scoring). Default 0.25. */
+    readonly rejectionNegativeThreshold?: number;
+}
+export declare class DualConfidenceStrategy implements BaseResearchStrategy {
+    readonly name = "dual-confidence";
+    private readonly opts;
+    constructor(options?: DualConfidenceOptions);
+    run(query: string, context: ResearchContext): Promise<ResearchResult>;
+    /** Bucket a dual-confidence score. Public for testability. */
+    bucket(score: DualConfidenceScore): ResearchCitation["confidence"];
+}
+//# sourceMappingURL=dual-confidence.d.ts.map

package/dist/intelligence/research-loops/strategies/dual-confidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-confidence.d.ts","sourceRoot":"","sources":["../../../../src/intelligence/research-loops/strategies/dual-confidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EAErB,KAAK,cAAc,EACnB,KAAK,SAAS,EAKf,MAAM,oBAAoB,CAAC;AAI5B,sDAAsD;AACtD,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAE/F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,qFAAqF;IACrF,QAAQ,CAAC,0BAA0B,CAAC,EAAE,MAAM,CAAC;CAC9C;AAYD,qBAAa,sBAAuB,YAAW,oBAAoB;IACjE,QAAQ,CAAC,IAAI,qBAAiB;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;gBAE3B,OAAO,GAAE,qBAA0B;IAYzC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAsG3E,8DAA8D;IAC9D,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,gBAAgB,CAAC,YAAY,CAAC;CAiBnE"}

package/dist/intelligence/research-loops/strategies/dual-confidence.js

@@ -0,0 +1,172 @@
+/**
+ * Dual-Confidence with Rejection strategy — ported from LDR
+ * `advanced_search_system/strategies/dual_confidence_with_rejection.py`
+ * (and its parent `dual_confidence_strategy.py`).
+ *
+ * For each search hit, the strategy scores POSITIVE evidence (does the
+ * hit support the query?) and NEGATIVE evidence (does it actively
+ * contradict the query?). Hits are bucketed into three pools:
+ *   - high     pos ≥ HIGH_POSITIVE         and neg ≤ MAX_NEGATIVE_FOR_HIGH
+ *   - medium   pos ≥ MEDIUM_POSITIVE       and neg ≤ MAX_NEGATIVE_FOR_MEDIUM
+ *   - rejected anything else (logged but excluded from final answer)
+ *
+ * The "with rejection" variant adds an EARLY-REJECTION shortcut: if a
+ * hit's average negative > REJECTION_NEGATIVE_THRESHOLD, it's dropped
+ * before scoring positive evidence (LDR's `_evaluate_candidate_immediately`
+ * logic). This saves provider tokens.
+ *
+ * The confidence scorer is INJECTABLE — tests provide deterministic
+ * scores; production wires an LLM-backed judge. A missing scorer
+ * yields a single fixture finding with stop="no-provider" semantics.
+ *
+ * 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_TOOL_CALLS_PER_RUN, clampMax, requireProvider, } from "./base-strategy.js";
+const STRATEGY_NAME = "dual-confidence";
+export class DualConfidenceStrategy {
+    name = STRATEGY_NAME;
+    opts;
+    constructor(options = {}) {
+        this.opts = Object.freeze({
+            maxToolCalls: clampMax(options.maxToolCalls, MAX_TOOL_CALLS_PER_RUN, MAX_TOOL_CALLS_PER_RUN),
+            highPositive: options.highPositive ?? 0.7,
+            maxNegativeForHigh: options.maxNegativeForHigh ?? 0.1,
+            mediumPositive: options.mediumPositive ?? 0.4,
+            maxNegativeForMedium: options.maxNegativeForMedium ?? 0.3,
+            rejectionNegativeThreshold: options.rejectionNegativeThreshold ?? 0.25,
+            scorer: options.scorer,
+        });
+    }
+    async run(query, context) {
+        if (typeof query !== "string" || query.length === 0) {
+            throw new Error("dual-confidence: query must be non-empty string");
+        }
+        const noProvider = requireProvider(context, STRATEGY_NAME);
+        if (noProvider)
+            return Object.freeze({ ...noProvider, query });
+        const collector = new ResearchResultsCollector();
+        let toolCalls = 0;
+        let stopReason = "completed";
+        let hits;
+        try {
+            const out = await context.provider(query);
+            hits = Array.isArray(out) ? out : [];
+        }
+        catch {
+            return Object.freeze({
+                strategy: STRATEGY_NAME,
+                query,
+                findings: Object.freeze([]),
+                toolCalls: 0,
+                stopReason: "provider-error",
+                ok: false,
+            });
+        }
+        toolCalls += 1;
+        if (hits.length === 0) {
+            return Object.freeze({
+                strategy: STRATEGY_NAME,
+                query,
+                findings: Object.freeze([]),
+                toolCalls,
+                stopReason: "no-results",
+                ok: false,
+            });
+        }
+        const assignedIndices = collector.addResults(hits, "dual-confidence");
+        // If no scorer is wired, return an honest fixture finding so misuse
+        // is obvious. This mirrors the budgeted-research "no-runner" pattern.
+        if (!this.opts.scorer) {
+            const finding = Object.freeze({
+                question: query,
+                content: "[fixture-scorer] dual-confidence has no scorer wired; returning unscored hits",
+                citations: collector.citations(),
+            });
+            return Object.freeze({
+                strategy: STRATEGY_NAME,
+                query,
+                findings: Object.freeze([finding]),
+                toolCalls,
+                stopReason: "completed",
+                ok: false,
+            });
+        }
+        // Score each hit. Early rejection skips positive scoring when
+        // negative evidence is already conclusive (LDR `_evaluate_candidate_immediately`).
+        for (let i = 0; i < hits.length; i++) {
+            if (toolCalls >= this.opts.maxToolCalls) {
+                stopReason = "max-tool-calls";
+                break;
+            }
+            const hit = hits[i];
+            const idx = assignedIndices[i];
+            if (!hit || idx === undefined || idx === 0)
+                continue;
+            let score;
+            try {
+                score = await this.opts.scorer(query, hit);
+                toolCalls += 1;
+            }
+            catch {
+                collector.setConfidence(idx, "rejected");
+                continue;
+            }
+            const bucket = this.bucket(score);
+            collector.setConfidence(idx, bucket);
+        }
+        const high = collector.citationsAtConfidence("high");
+        const medium = collector.citationsAtConfidence("medium");
+        const rejected = collector.citationsAtConfidence("rejected");
+        const keep = Object.freeze([...high, ...medium]);
+        const content = summarize(query, high, medium, rejected);
+        const finding = Object.freeze({
+            question: query,
+            content,
+            citations: keep,
+        });
+        return Object.freeze({
+            strategy: STRATEGY_NAME,
+            query,
+            findings: Object.freeze([finding]),
+            toolCalls,
+            stopReason,
+            ok: true,
+        });
+    }
+    /** Bucket a dual-confidence score. Public for testability. */
+    bucket(score) {
+        if (!Number.isFinite(score.positive) || !Number.isFinite(score.negative))
+            return "rejected";
+        if (score.negative > this.opts.rejectionNegativeThreshold)
+            return "rejected";
+        if (score.positive >= this.opts.highPositive &&
+            score.negative <= this.opts.maxNegativeForHigh) {
+            return "high";
+        }
+        if (score.positive >= this.opts.mediumPositive &&
+            score.negative <= this.opts.maxNegativeForMedium) {
+            return "medium";
+        }
+        return "rejected";
+    }
+}
+function summarize(query, high, medium, rejected) {
+    const lines = [];
+    lines.push(`# Dual-confidence answer for: ${query}`);
+    lines.push(`High-confidence: ${high.length}, Medium-confidence: ${medium.length}, Rejected: ${rejected.length}`);
+    if (high.length > 0) {
+        lines.push("\n## High-confidence sources");
+        for (const c of high)
+            lines.push(`- [${c.index}] ${c.hit.title}`);
+    }
+    if (medium.length > 0) {
+        lines.push("\n## Medium-confidence sources");
+        for (const c of medium)
+            lines.push(`- [${c.index}] ${c.hit.title}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=dual-confidence.js.map

package/dist/intelligence/research-loops/strategies/dual-confidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-confidence.js","sourceRoot":"","sources":["../../../../src/intelligence/research-loops/strategies/dual-confidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAQL,sBAAsB,EACtB,QAAQ,EACR,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,aAAa,GAAG,iBAAiB,CAAC;AAqCxC,MAAM,OAAO,sBAAsB;IACxB,IAAI,GAAG,aAAa,CAAC;IACb,IAAI,CAAkB;IAEvC,YAAY,UAAiC,EAAE;QAC7C,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;YACxB,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,YAAY,EAAE,sBAAsB,EAAE,sBAAsB,CAAC;YAC5F,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,GAAG;YACzC,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,GAAG;YACrD,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,GAAG;YAC7C,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,IAAI,GAAG;YACzD,0BAA0B,EAAE,OAAO,CAAC,0BAA0B,IAAI,IAAI;YACtE,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,KAAa,EAAE,OAAwB;QAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QACD,MAAM,UAAU,GAAG,eAAe,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC3D,IAAI,UAAU;YAAE,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QAE/D,MAAM,SAAS,GAAG,IAAI,wBAAwB,EAAE,CAAC;QACjD,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,UAAU,GAAuB,WAAW,CAAC;QAEjD,IAAI,IAA0B,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC1C,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,MAAM,CAAC,MAAM,CAAC;gBACnB,QAAQ,EAAE,aAAa;gBACvB,KAAK;gBACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAoB,EAAE,CAAC;gBAC9C,SAAS,EAAE,CAAC;gBACZ,UAAU,EAAE,gBAAgB;gBAC5B,EAAE,EAAE,KAAK;aACV,CAAC,CAAC;QACL,CAAC;QACD,SAAS,IAAI,CAAC,CAAC;QAEf,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC,MAAM,CAAC;gBACnB,QAAQ,EAAE,aAAa;gBACvB,KAAK;gBACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAoB,EAAE,CAAC;gBAC9C,SAAS;gBACT,UAAU,EAAE,YAAY;gBACxB,EAAE,EAAE,KAAK;aACV,CAAC,CAAC;QACL,CAAC;QAED,MAAM,eAAe,GAAG,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;QAEtE,oEAAoE;QACpE,sEAAsE;QACtE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACtB,MAAM,OAAO,GAAoB,MAAM,CAAC,MAAM,CAAC;gBAC7C,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,+EAA+E;gBACxF,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE;aACjC,CAAC,CAAC;YACH,OAAO,MAAM,CAAC,MAAM,CAAC;gBACnB,QAAQ,EAAE,aAAa;gBACvB,KAAK;gBACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;gBAClC,SAAS;gBACT,UAAU,EAAE,WAAW;gBACvB,EAAE,EAAE,KAAK;aACV,CAAC,CAAC;QACL,CAAC;QAED,8DAA8D;QAC9D,mFAAmF;QACnF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;gBACxC,UAAU,GAAG,gBAAgB,CAAC;gBAC9B,MAAM;YACR,CAAC;YACD,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,MAAM,GAAG,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,CAAC;gBAAE,SAAS;YACrD,IAAI,KAA0B,CAAC;YAC/B,IAAI,CAAC;gBACH,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBAC3C,SAAS,IAAI,CAAC,CAAC;YACjB,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;gBACzC,SAAS;YACX,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAClC,SAAS,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACvC,CAAC;QAED,MAAM,IAAI,GAAG,SAAS,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACrD,MAAM,MAAM,GAAG,SAAS,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QACzD,MAAM,QAAQ,GAAG,SAAS,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;QAC7D,MAAM,IAAI,GAAgC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;QAE9E,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QACzD,MAAM,OAAO,GAAoB,MAAM,CAAC,MAAM,CAAC;YAC7C,QAAQ,EAAE,KAAK;YACf,OAAO;YACP,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,QAAQ,EAAE,aAAa;YACvB,KAAK;YACL,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAoB,CAAC,OAAO,CAAC,CAAC;YACrD,SAAS;YACT,UAAU;YACV,EAAE,EAAE,IAAI;SACT,CAAC,CAAC;IACL,CAAC;IAED,8DAA8D;IAC9D,MAAM,CAAC,KAA0B;QAC/B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC;YAAE,OAAO,UAAU,CAAC;QAC5F,IAAI,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,0BAA0B;YAAE,OAAO,UAAU,CAAC;QAC7E,IACE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY;YACxC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAC9C,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IACE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc;YAC1C,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAChD,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;CACF;AAED,SAAS,SAAS,CAChB,KAAa,EACb,IAAiC,EACjC,MAAmC,EACnC,QAAqC;IAErC,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,CAAC,IAAI,CAAC,iCAAiC,KAAK,EAAE,CAAC,CAAC;IACrD,KAAK,CAAC,IAAI,CACR,oBAAoB,IAAI,CAAC,MAAM,wBAAwB,MAAM,CAAC,MAAM,eAAe,QAAQ,CAAC,MAAM,EAAE,CACrG,CAAC;IACF,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;QAC3C,KAAK,MAAM,CAAC,IAAI,IAAI;YAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,KAAK,CAAC,IAAI,CAAC,gCAAgC,CAAC,CAAC;QAC7C,KAAK,MAAM,CAAC,IAAI,MAAM;YAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}