@tangle-network/agent-knowledge 1.10.0 → 1.11.0

package/docs/two-agent-research-ab.md

@@ -33,7 +33,15 @@ LLM verifier calls 76% and dollars 74%, recovering the de-dup half of the
 verifier's cleanliness while honestly giving up the relevance-judgment half on a
 source pool dominated by authoritative hosts. The verifier earns its dollar on
 misattribution, not on de-duplication; the right production loop spends it only
-where the cheap signals can't decide.
+where the cheap signals can't decide. Finally we ask the harder question this whole
+metric can't reach — a filter agent can only make the base *carry less*, never
+*answer more* — by building the opposite agent (a **driving** driver that chases
+depth and corroboration instead of pruning) and the opposite metric (a firewalled
+exam of 20 held-out **deep questions**, $0-graded). It is an honest null: driving
+does **not** reliably beat plain collection at answering hard questions, and costs
+**12–16×** more; the verdict flips with the compute budget, the signature of web
+variance rather than a real topology effect, and it still ties a blind worker even
+when forced to run its full multi-round mechanism (§9).
 
 ## 1. Setup
 
@@ -93,10 +101,8 @@ proposed. It talks to the router directly through `createTangleRouterClient` —
 claude-code / opencode / sandbox harness, and no dynamic harness selection. The
 driver (`createVerifyingResearchDriver`) is one glm-5.2 chat call per source.
 
-The repo *does* ship a real `AgentProfile` for research (`researcherProfile`), and
-the **offline** control arm uses it with a stub harness — but the live arm bypasses
-it for the direct pipeline. This is a deliberate shortcut (no harness to stand up,
-~$0.20 to run) and also the loop's main simplification debt; see §7.
+The package keeps the live research mechanics runner-agnostic.
+Agent profiles and sandbox-backed runners now live in `agent-runtime`; this package owns the source, write, validation, and eval layer.
 
 ### 2.3 Equal compute
 
@@ -370,17 +376,109 @@ measured; this is what changed.
 
 What is still **not** built remains the worker: the live worker is a ~500-line
 hand-wired pipeline (query-gen, search, fetch, propose) against the router directly,
-where the repo's own pattern is to *author* an `AgentProfile` (`researcherProfile`)
+where the runtime integration's pattern is to author an agent profile
 and run it on a harness with a web-search tool — reusable and harness-agnostic. The
 direct pipeline is cheaper to run today (no harness, no creds beyond the router) but it
 is the loop's main remaining piece of duplication, and the obvious next step if this
 loop graduates from experiment to production.
 
-## 9. Reproduce
+## 9. From hygiene to depth — a research-DRIVING loop, measured on held-out deep questions
+
+Everything above measures one thing: **source hygiene** — how *few* sources a verifier
+admits at equal coverage. That is the right metric for a verifier whose only job is to
+filter, and it is why the win turned out to be de-duplication (§4.1): the most a
+filter-only verifier can do is reject. By construction it cannot make the knowledge base
+*answer more*; it can only make it *carry less*. So "the verifier mostly deduplicates" is
+not a disappointing finding about *this* verifier — it is the ceiling of what *any*
+admit-or-reject step can do. To ask whether a second agent can improve the research
+itself, you have to change both the agent and the metric.
+
+So we built the opposite agent and gave it the opposite metric. The **driving driver**
+(`src/research-driving-driver.ts`, `createResearchDrivingDriver`) does not filter. It
+extracts each fetched source's claims, demands a second independent source for every
+claim, generates comparative / mechanism / contradiction sub-questions, and steers the
+worker to chase them in the next round. Its thesis is that *driving the research deeper*
+— not pruning it — builds a knowledge base that answers harder questions. We measure it
+not on admitted-count (which would score its whole point as a regression — it admits
+*more*) but on a **firewalled exam of 20 deep questions across 5 ML topics**
+(`tests/loops/held-out-exam.ts`), graded with a $0 deterministic substring grader the
+loop never sees. The questions are depth questions by construction — the grader scores
+**0/20** on a one-line topic definition and **20/20** on a mechanism-rich paragraph, so
+a high score is reachable only by depth, not by grader slack. All three arms run the
+same real web worker and differ only in the driver: (A) plain collection, (B)
+verify/dedup, (C) driving.
+
+**The honest verdict: driving does NOT reliably beat plain collection, and costs
+~12–16× more.** The tell is that the winner flips with the compute budget, on the same
+exam:
+
+| arm | answered @ B=4 | answered @ B=6 | cost (5 topics) | tokens |
+|---|---|---|---|---|
+| single-agent (collect) | 13/20 | **15/20** | $0.005–0.007 | ~2.4–3.0k |
+| verify/dedup | **15/20** | **15/20** | $0.031–0.027 | ~21k |
+| **driving (deepen)** | **16/20** | 13/20 | **$0.089–0.084** | ~69–71k |
+
+Driving "wins" at B=4 (16 > 15 > 13) and "loses" at B=6 (13 < 15), while the
+single-agent arm itself swings 15→13 across the two budgets. At n=5 topics a ±1–3
+question difference is inside the run-to-run web variance — the **within-arm swing is as
+large as the between-arm gap**, which is the signature of a null. What is stable and
+large is the cost: an order of magnitude more dollars and ~24× the tokens, for the
+claim-extraction LLM call driving runs on every fetched source.
+
+The autopsy explains it: every arm finished in **one effective round**
+(`passes=2` on every topic at every budget). The generic readiness gate — "one source
+closes the gap" — is met by the first fetch, so the loop stops *before* the driving
+driver ever steers a second round, and its entire mechanism is multi-round. So we gave
+it its fairest test: a controlled probe that *forces* three rounds so the driver
+actually steers. It **still ties** a blind worker that just re-searches the same gaps —
+**8/12 vs 8/12, at ~9× the cost**. Driving was better on RLHF (3 vs 1 — chasing
+corroboration reached a page blind search missed) and worse on speculative decoding (2
+vs 4 — steering pulled the worker *off* the pages that answered the exam); the two
+cancel. The null survives the fix, so it is not an artifact of a permissive gate.
+
+The durable output is the apparatus, not the agent: a firewalled deep-question exam with
+a $0 grader that can tell depth from surface, reusable for any future research-quality
+claim. Full result, per-topic tables, and the probe: [`docs/results/research-driving.md`](results/research-driving.md).
+The two findings compose into one rule for "should I add a second research agent?":
+a **filter** agent measured on hygiene buys de-dup cleanliness you can get cheaper from a
+hash (§3–§4); a **driver** agent measured on depth buys nothing reliable over plain
+collection at this n and worker, for 9–16× the cost (§9). Neither earns a blanket "yes";
+both earn a narrow, cost-stratified one — the verifier on misattribution and the
+off-scope tail (§5), the driver only where a richer worker makes "go corroborate this"
+reach a page collection can't.
+
+### 9.1 The domain was too easy — re-running the A/B where one search is not enough
+
+The §9 null has a structural cause, not a measurement one: **on an ML topic a single
+good search already collects the answer.** Every arm finished in one effective round
+because the first fetch met the readiness gate, so the driving driver — whose mechanism
+is steering a *second* round — never acted. When one search suffices, there is no
+investigation for a smarter coordinator to do, and the metric can only reward
+collection. To ask whether topology *can ever* beat blind collection, you have to move
+to a domain where the answer is buried and a single fetch provably cannot surface it.
+
+So we did. We ported the whole apparatus — firewalled checklist, `$0` model-free
+grader, matched-compute 3-arm A/B — onto **investment research**: give a loop a company
++ ticker + an as-of cutoff and grade the thesis on the buried, material 10-K-footnote
+facts a ticker search misses (an HTM mark the size of a bank's equity, a 97%-uninsured
+deposit base, a negative per-unit margin). First we *calibrated* the new metric and
+proved it discriminates depth on this harder domain — a shallow ticker summary scores
+**1/27 (4%)**, a deep filings-grounded thesis **27/27 (100%)**, a **+96-point** gap.
+Then the live 3-arm A/B over 5 held-out companies: **driving surfaced the most buried
+facts (16/27, 59%) vs blind collection (11/27, 41%)** for ~1.9× the cost — the lift is
+real and points the right way, but at n=5 the paired-bootstrap CI still crosses zero
+(P(Δ≤0)=0.08), and verify did not beat collection (10/27). So the verdict survives the
+domain change: **no topology *significantly* beats collection — but on a domain where
+the answer must be investigated for, driving is the only arm that even leans positive,
+and it does so suggestively, not significantly.** Full reframe, calibration, and
+per-company A/B: [`docs/results/investment-thesis.md`](results/investment-thesis.md).
+
+## 10. Reproduce
 
 The loop, the worker, the verifier, the claim-grounding mode, the adaptive driver, the
-cost instrumentation, and every A/B are all in this repository. Each live test gates a
-cheap one-call glm-5.2 smoke before any multi-topic burn.
+driving driver, the held-out exam, the cost instrumentation, and every A/B are all in
+this repository. Each live test gates a cheap one-call glm-5.2 smoke before any
+multi-topic burn.
 
 ```bash
 git clone https://github.com/tangle-network/agent-knowledge
@@ -410,6 +508,15 @@ AGENT_KNOWLEDGE_LIVE=1 TANGLE_API_KEY=<…> \
 AGENT_KNOWLEDGE_LIVE=1 TANGLE_API_KEY=<…> \
   ADAPTIVE_LIVE_GOALS="self-speculative decoding|rotary position embeddings|grouped-query attention|KV-cache quantization|LoRA fine-tuning" \
   pnpm exec vitest run tests/loops/adaptive-ab.test.ts -t "three-topology"
+
+# the research-DRIVING 3-arm A/B (§9) — collect / verify / drive, graded on the
+# held-out deep-question exam; re-run at RQ_LIVE_BUDGET=6 to see the verdict flip
+AGENT_KNOWLEDGE_LIVE=1 RQ_LIVE_BUDGET=4 TANGLE_API_KEY=<…> \
+  pnpm exec vitest run tests/loops/research-driving-ab.test.ts -t "3-arm A/B"
+
+# the controlled multi-round probe — forces 3 rounds so the driver actually steers
+AGENT_KNOWLEDGE_LIVE=1 RQ_PROBE=1 RQ_PROBE_ROUNDS=3 TANGLE_API_KEY=<…> \
+  pnpm exec vitest run tests/loops/research-driving-ab.test.ts -t "multi-round probe"
 ```
 
 `AGENT_KNOWLEDGE_LIVE_GOALS` (and the per-result `*_LIVE_GOALS`) take a `|`-separated
@@ -420,9 +527,13 @@ bootstrap and per-arm cost.
 the live worker + verifier + cost instrumentation — [`src/web-research-worker.ts`](../src/web-research-worker.ts);
 the misattribution check — [`src/claim-grounding.ts`](../src/claim-grounding.ts);
 the adaptive driver — [`src/adaptive-driver.ts`](../src/adaptive-driver.ts);
+the driving driver — [`src/research-driving-driver.ts`](../src/research-driving-driver.ts);
+the held-out exam + $0 grader — [`tests/loops/held-out-exam.ts`](../tests/loops/held-out-exam.ts);
 the A/B harnesses — [`tests/loops/`](../tests/loops/).
 Per-result detail: [`docs/results/cost-quality.md`](results/cost-quality.md),
 [`docs/results/claim-grounding.md`](results/claim-grounding.md),
-[`docs/results/adaptive.md`](results/adaptive.md).
+[`docs/results/adaptive.md`](results/adaptive.md),
+[`docs/results/research-driving.md`](results/research-driving.md),
+[`docs/results/investment-thesis.md`](results/investment-thesis.md) (§9.1 — the domain reframe + calibration + 3-arm A/B).
 </content>
 </invoke>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-knowledge",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Source-grounded, eval-gated knowledge growth primitives for agents.",
   "homepage": "https://github.com/tangle-network/agent-knowledge#readme",
   "repository": {
@@ -39,10 +39,10 @@
       "import": "./dist/sources/index.js",
       "default": "./dist/sources/index.js"
     },
-    "./profiles": {
-      "types": "./dist/profiles/index.d.ts",
-      "import": "./dist/profiles/index.js",
-      "default": "./dist/profiles/index.js"
+    "./benchmarks": {
+      "types": "./dist/benchmarks/index.d.ts",
+      "import": "./dist/benchmarks/index.js",
+      "default": "./dist/benchmarks/index.js"
     }
   },
   "bin": {
@@ -68,16 +68,16 @@
     "format": "biome format --write src tests"
   },
   "dependencies": {
-    "@tangle-network/agent-eval": "^0.100.0",
-    "@tangle-network/agent-runtime": "^0.77.0",
+    "@tangle-network/agent-eval": "^0.107.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.15",
     "@neo4j-labs/agent-memory": "0.4.0",
-    "@tangle-network/sandbox": "^0.8.0",
+    "@tangle-network/sandbox": "^0.9.7",
     "@types/node": "^25.6.0",
     "tsup": "^8.0.0",
+    "tsx": "^4.22.4",
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   },
@@ -85,7 +85,6 @@
     "minimumReleaseAge": 4320,
     "minimumReleaseAgeExclude": [
       "@tangle-network/agent-eval",
-      "@tangle-network/agent-runtime",
       "@tangle-network/sandbox"
     ]
   },

package/dist/chunk-MU5CEOGE.js

@@ -1,387 +0,0 @@
-// src/profiles/researcher.ts
-var DEFAULT_HARNESS = "opencode/zai-coding-plan/glm-5.1";
-var DEFAULT_CITATION_DENSITY_MIN = 0.7;
-function researcherProfile(options = {}) {
-  const harness = options.harness ?? DEFAULT_HARNESS;
-  const name = options.name ?? `researcher-${harness}`;
-  const systemPrompt = options.systemPrompt ?? DEFAULT_RESEARCHER_SYSTEM_PROMPT;
-  const citationDensityMin = options.citationDensityMin ?? DEFAULT_CITATION_DENSITY_MIN;
-  const profile = {
-    name,
-    description: "Source-grounded research agent. Propose-don't-apply.",
-    prompt: { systemPrompt },
-    model: options.model ? { default: options.model } : void 0,
-    tools: { web_search: true, fs: true, shell: true },
-    metadata: { backendType: harness, role: "researcher" }
-  };
-  const output = { parse: parseResearcherEvents };
-  const validator = options.task ? createResearcherValidator(options.task, { citationDensityMin }) : createResearcherValidator(
-    { question: "", knowledgeNamespace: "" },
-    { citationDensityMin, namespaceCheck: false }
-  );
-  const agentRunSpec = {
-    name,
-    profile,
-    taskToPrompt: formatResearcherPrompt
-  };
-  return { profile, taskToPrompt: formatResearcherPrompt, output, validator, agentRunSpec };
-}
-function multiHarnessResearcherFanout(options = {}) {
-  const harnesses = options.harnesses && options.harnesses.length > 0 ? options.harnesses : ["opencode/zai-coding-plan/glm-5.1", "claude-code", "codex"];
-  const models = options.models ?? [];
-  const agentRuns = harnesses.map((harness, i) => {
-    const { agentRunSpec } = researcherProfile({ harness, model: models[i] });
-    return agentRunSpec;
-  });
-  const { output, validator } = researcherProfile({
-    citationDensityMin: options.citationDensityMin,
-    task: options.task
-  });
-  const driver = {
-    name: "researcher-fanout",
-    async plan(task, history) {
-      return history.length === 0 ? Array.from({ length: harnesses.length }, () => task) : [];
-    },
-    // 'done' is a terminal decision in the kernel; the loop finalizes after
-    // the single fanout round and selects the winner via `defaultSelectWinner`.
-    decide() {
-      return "done";
-    },
-    describePlan() {
-      return { kind: "fanout" };
-    }
-  };
-  return { agentRuns, output, validator, driver };
-}
-function createResearcherValidator(task, config = {}) {
-  const citationDensityMin = config.citationDensityMin ?? DEFAULT_CITATION_DENSITY_MIN;
-  const namespaceCheck = config.namespaceCheck ?? true;
-  return {
-    async validate(output) {
-      const notes = [];
-      const scores = {};
-      let pass = true;
-      if (!Array.isArray(output.items) || output.items.length === 0) {
-        pass = false;
-        notes.push("no items");
-        scores.items = 0;
-      } else {
-        scores.items = 1;
-      }
-      const missingEvidence = (output.items ?? []).filter(
-        (item) => !Array.isArray(item.evidence) || item.evidence.length === 0
-      );
-      if (missingEvidence.length > 0) {
-        pass = false;
-        notes.push(`${missingEvidence.length} item(s) without evidence`);
-        scores.provenance = 0;
-      } else {
-        scores.provenance = 1;
-      }
-      if (namespaceCheck) {
-        const foreignItems = (output.items ?? []).filter(
-          (item) => item.namespace !== task.knowledgeNamespace
-        );
-        const foreignWrites = (output.proposedWrites ?? []).filter(
-          (write) => write.namespace !== task.knowledgeNamespace
-        );
-        if (foreignItems.length > 0 || foreignWrites.length > 0) {
-          pass = false;
-          notes.push(
-            `namespace violation: ${foreignItems.length} item(s) + ${foreignWrites.length} write(s) outside ${task.knowledgeNamespace}`
-          );
-          scores.namespace = 0;
-        } else {
-          scores.namespace = 1;
-        }
-      }
-      const itemCount = Math.max(output.items?.length ?? 0, 1);
-      const citationsWithQuote = (output.citations ?? []).filter(
-        (citation) => typeof citation.quote === "string" && citation.quote.length > 0
-      ).length;
-      const citationDensity = Math.min(1, citationsWithQuote / itemCount);
-      if (citationDensity < citationDensityMin) {
-        pass = false;
-        notes.push(
-          `citation density ${citationDensity.toFixed(2)} below floor ${citationDensityMin.toFixed(2)}`
-        );
-      }
-      scores.citation_density = citationDensity;
-      const sourceSet = /* @__PURE__ */ new Set();
-      for (const item of output.items ?? []) {
-        for (const evidence of item.evidence ?? []) {
-          if (evidence.source) sourceSet.add(evidence.source);
-        }
-      }
-      scores.source_diversity = Math.min(1, sourceSet.size / itemCount);
-      scores.recency_match = recencyMatchScore(output.items ?? [], task.recencyWindow);
-      const maxGaps = itemCount;
-      const gapCount = output.gaps?.length ?? 0;
-      scores.gap_coverage = Math.max(0, 1 - gapCount / maxGaps);
-      const score = 0.4 * scores.citation_density + 0.2 * scores.source_diversity + 0.2 * scores.recency_match + 0.2 * scores.gap_coverage;
-      const verdict = {
-        valid: pass,
-        score: Number.isFinite(score) ? score : 0,
-        scores
-      };
-      if (notes.length > 0) verdict.notes = notes.join("; ");
-      return verdict;
-    }
-  };
-}
-function recencyMatchScore(items, window) {
-  if (!window || window.since === void 0 && window.until === void 0) return 1;
-  if (items.length === 0) return 0;
-  const sinceMs = window.since?.getTime() ?? Number.NEGATIVE_INFINITY;
-  const untilMs = window.until?.getTime() ?? Number.POSITIVE_INFINITY;
-  let hits = 0;
-  let total = 0;
-  for (const item of items) {
-    for (const evidence of item.evidence ?? []) {
-      if (typeof evidence.capturedAt !== "number") continue;
-      total += 1;
-      if (evidence.capturedAt >= sinceMs && evidence.capturedAt <= untilMs) hits += 1;
-    }
-  }
-  return total === 0 ? 0 : hits / total;
-}
-var DEFAULT_RESEARCHER_SYSTEM_PROMPT = [
-  "You are a research agent. Your job is to answer a research question with",
-  "source-grounded knowledge items that the caller will choose whether to",
-  "persist to a multi-tenant knowledge base.",
-  "",
-  "Hard rules:",
-  "  1. Every item you emit MUST carry the task's knowledgeNamespace exactly.",
-  "     Never write to a different namespace.",
-  "  2. Every item MUST carry at least one evidence entry with a source.",
-  "     A quote + url is strongly preferred; capturedAt is unix ms.",
-  "  3. You propose writes \u2014 you do NOT apply them. The caller decides.",
-  "  4. Self-report confidence honestly in [0, 1]. Do not inflate.",
-  "  5. List what you could not answer in `gaps`. Better to admit a gap",
-  "     than fabricate.",
-  "",
-  "When you finish, emit a single final structured message of the shape:",
-  "  ```json",
-  '  { "items": [{ "id": "...", "namespace": "...", "claim": "...",',
-  '                "evidence": [{ "source": "...", "quote": "...",',
-  '                               "url": "...", "capturedAt": 0 }],',
-  '                "confidence": 0.0,',
-  '                "authoredBy": { "kind": "agent", "id": "..." } }],',
-  '    "citations": [{ "url": "...", "quote": "...", "confidence": 0.0 }],',
-  '    "proposedWrites": [{ "kind": "insert", "namespace": "...",',
-  '                         "item": { /* same shape as items[] */ } }],',
-  '    "gaps": ["..."],',
-  '    "notes": "free-form commentary" }',
-  "  ```"
-].join("\n");
-function formatResearcherPrompt(task) {
-  const sources = task.sources?.length ? task.sources.join(", ") : "(no preference)";
-  const window = formatRecencyWindow(task.recencyWindow);
-  return [
-    `Question: ${task.question}`,
-    `Knowledge namespace (DO NOT cross): ${task.knowledgeNamespace}`,
-    `Scope: ${task.scope ?? "(unspecified)"}`,
-    `Preferred sources: ${sources}`,
-    `Recency window: ${window}`,
-    `Max items: ${task.maxItems ?? "(no cap)"}`,
-    `Per-item minimum confidence: ${task.minConfidence ?? "(no floor)"}`,
-    "",
-    "Produce knowledge items with provenance + citations + proposed writes.",
-    "List gaps for anything you could not answer. Emit the final JSON",
-    "result block exactly as instructed."
-  ].join("\n");
-}
-function formatRecencyWindow(window) {
-  if (!window) return "(none)";
-  const since = window.since ? window.since.toISOString() : "-\u221E";
-  const until = window.until ? window.until.toISOString() : "now";
-  return `${since} .. ${until}`;
-}
-function parseResearcherEvents(events) {
-  for (let i = events.length - 1; i >= 0; i -= 1) {
-    const event = events[i];
-    if (!event) continue;
-    const type = String(event.type ?? "");
-    const data = isRecord(event.data) ? event.data : {};
-    if (type === "result" || type === "final" || type === "research.result") {
-      const direct = coerceResearchOutput(data.result ?? data.output ?? data);
-      const finalText = pickString(data.finalText);
-      const fenced = finalText ? extractFencedJson(finalText) : void 0;
-      const fromFinalText = fenced ? coerceResearchOutput(fenced) : void 0;
-      if (direct && !isEmptyOutput(direct)) return direct;
-      if (fromFinalText) return fromFinalText;
-      if (direct) return direct;
-    }
-  }
-  for (let i = events.length - 1; i >= 0; i -= 1) {
-    const event = events[i];
-    if (!event) continue;
-    const data = isRecord(event.data) ? event.data : {};
-    const text = pickString(data.text) ?? pickString(data.delta) ?? pickString(data.finalText);
-    if (!text) continue;
-    const fenced = extractFencedJson(text);
-    if (!fenced) continue;
-    const coerced = coerceResearchOutput(fenced);
-    if (coerced) return coerced;
-  }
-  return { items: [], citations: [], proposedWrites: [] };
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isEmptyOutput(o) {
-  return o.items.length === 0 && o.citations.length === 0 && o.proposedWrites.length === 0;
-}
-function pickString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function extractFencedJson(text) {
-  const match = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  if (!match) return void 0;
-  const body = (match[1] ?? "").trim();
-  if (!body) return void 0;
-  try {
-    return JSON.parse(body);
-  } catch {
-    return void 0;
-  }
-}
-function coerceResearchOutput(value) {
-  if (!isRecord(value)) return void 0;
-  const items = coerceItems(value.items);
-  const citations = coerceCitations(value.citations);
-  const proposedWrites = coerceProposedWrites(value.proposedWrites);
-  if (items === void 0 && citations === void 0 && proposedWrites === void 0) {
-    return void 0;
-  }
-  const output = {
-    items: items ?? [],
-    citations: citations ?? [],
-    proposedWrites: proposedWrites ?? []
-  };
-  if (Array.isArray(value.gaps)) {
-    output.gaps = value.gaps.filter((entry) => typeof entry === "string");
-  }
-  const notes = pickString(value.notes);
-  if (notes) output.notes = notes;
-  const known = /* @__PURE__ */ new Set(["items", "citations", "proposedWrites", "gaps", "notes"]);
-  const extras = {};
-  let extrasCount = 0;
-  for (const [key, val] of Object.entries(value)) {
-    if (known.has(key)) continue;
-    extras[key] = val;
-    extrasCount += 1;
-  }
-  if (extrasCount > 0) output.raw = extras;
-  return output;
-}
-function coerceItems(value) {
-  if (!Array.isArray(value)) return void 0;
-  const out = [];
-  for (const entry of value) {
-    if (!isRecord(entry)) continue;
-    const id = pickString(entry.id);
-    const namespace = pickString(entry.namespace);
-    const claim = pickString(entry.claim);
-    const evidence = coerceEvidence(entry.evidence);
-    const confidence = toFiniteNumber(entry.confidence);
-    const authoredBy = coerceAuthoredBy(entry.authoredBy);
-    if (!id || !namespace || !claim || !authoredBy) continue;
-    const item = {
-      id,
-      namespace,
-      claim,
-      evidence,
-      confidence: clamp01(confidence),
-      authoredBy
-    };
-    if (Array.isArray(entry.supersedes)) {
-      item.supersedes = entry.supersedes.filter((s) => typeof s === "string");
-    }
-    const retractedAt = toFiniteNumber(entry.retractedAt);
-    if (retractedAt > 0) item.retractedAt = retractedAt;
-    out.push(item);
-  }
-  return out;
-}
-function coerceEvidence(value) {
-  if (!Array.isArray(value)) return [];
-  const out = [];
-  for (const entry of value) {
-    if (!isRecord(entry)) continue;
-    const source = pickString(entry.source);
-    if (!source) continue;
-    const item = {
-      source,
-      capturedAt: toFiniteNumber(entry.capturedAt)
-    };
-    const quote = pickString(entry.quote);
-    if (quote) item.quote = quote;
-    const url = pickString(entry.url);
-    if (url) item.url = url;
-    out.push(item);
-  }
-  return out;
-}
-function coerceAuthoredBy(value) {
-  if (!isRecord(value)) return void 0;
-  const kind = value.kind === "human" || value.kind === "agent" ? value.kind : void 0;
-  const id = pickString(value.id);
-  if (!kind || !id) return void 0;
-  return { kind, id };
-}
-function coerceCitations(value) {
-  if (!Array.isArray(value)) return void 0;
-  const out = [];
-  for (const entry of value) {
-    if (!isRecord(entry)) continue;
-    const url = pickString(entry.url);
-    const quote = pickString(entry.quote);
-    if (!url || !quote) continue;
-    out.push({ url, quote, confidence: clamp01(toFiniteNumber(entry.confidence)) });
-  }
-  return out;
-}
-function coerceProposedWrites(value) {
-  if (!Array.isArray(value)) return void 0;
-  const out = [];
-  for (const entry of value) {
-    if (!isRecord(entry)) continue;
-    const namespace = pickString(entry.namespace);
-    if (!namespace) continue;
-    if (entry.kind === "insert") {
-      const items = coerceItems([entry.item]);
-      const item = items?.[0];
-      if (!item) continue;
-      out.push({ kind: "insert", namespace, item });
-    } else if (entry.kind === "supersede") {
-      const previousId = pickString(entry.previousId);
-      const items = coerceItems([entry.item]);
-      const item = items?.[0];
-      if (!previousId || !item) continue;
-      out.push({ kind: "supersede", namespace, previousId, item });
-    } else if (entry.kind === "retract") {
-      const itemId = pickString(entry.itemId);
-      const reason = pickString(entry.reason);
-      if (!itemId || !reason) continue;
-      out.push({ kind: "retract", namespace, itemId, reason });
-    }
-  }
-  return out;
-}
-function toFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
-export {
-  researcherProfile,
-  multiHarnessResearcherFanout,
-  createResearcherValidator
-};
-//# sourceMappingURL=chunk-MU5CEOGE.js.map