@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/brain-consolidator-JGm6mzFf.js

@@ -1,373 +0,0 @@
-import { m as getBrainDb, k as getBrainNativeDb } from './sqlite-Bm5LzbPs.js';
-import { t as typedAll } from './typed-query-l1D_QElt.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './chunk-DDP5xfzh.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-
-//#region ../core/dist/memory/brain-consolidator.js
-/**
-* Brain Consolidator — contradiction detection for the CLEO BRAIN memory system.
-*
-* Implements heuristic contradiction detection based on keyword polarity flip.
-* No LLM required — uses negation markers to identify entries that assert
-* opposing claims about the same subject.
-*
-* When a contradiction is detected:
-*   1. A 'contradicts' edge is created in brain_page_edges (both directions).
-*   2. The lower-quality entry's qualityScore is reduced by 0.15.
-*
-* All operations are BEST-EFFORT — failures never crash the consolidator.
-*
-* @task T549 Wave 3-C
-* @epic T549
-*/
-/** Minimum number of shared keywords to consider two entries related. */
-var MIN_SHARED_KEYWORDS = 3;
-/**
-* Negation markers that, when present in one entry but not the other,
-* indicate a potential contradiction.
-*/
-var NEGATION_MARKERS = [
-	"not",
-	"never",
-	"deprecated",
-	"removed",
-	"replaced",
-	"avoid",
-	"no longer",
-	"do not",
-	"don't",
-	"disabled",
-	"deleted",
-	"dropped",
-	"broken",
-	"invalid",
-	"obsolete",
-	"reverted",
-	"undone",
-	"superseded"
-];
-/** Stop words excluded from keyword extraction (matches brain-lifecycle stop words). */
-var STOP_WORDS = new Set([
-	"the",
-	"a",
-	"an",
-	"is",
-	"are",
-	"was",
-	"were",
-	"be",
-	"been",
-	"being",
-	"have",
-	"has",
-	"had",
-	"do",
-	"does",
-	"did",
-	"will",
-	"would",
-	"could",
-	"should",
-	"may",
-	"might",
-	"shall",
-	"can",
-	"to",
-	"of",
-	"in",
-	"for",
-	"on",
-	"with",
-	"at",
-	"by",
-	"from",
-	"as",
-	"into",
-	"through",
-	"and",
-	"but",
-	"or",
-	"nor",
-	"so",
-	"yet",
-	"this",
-	"that",
-	"these",
-	"those",
-	"it",
-	"its",
-	"not",
-	"no"
-]);
-/**
-* Extract significant keywords from text for overlap comparison.
-* Filters stop words and tokens shorter than 4 characters.
-*/
-function extractKeywords(text) {
-	const words = text.toLowerCase().replace(/[^a-z0-9\s\-_]/g, " ").split(/\s+/);
-	const keywords = /* @__PURE__ */ new Set();
-	for (const w of words) if (w.length >= 4 && !STOP_WORDS.has(w)) keywords.add(w);
-	return keywords;
-}
-/**
-* Find negation markers present in the text.
-*/
-function findNegationMarkers(text) {
-	const lower = text.toLowerCase();
-	return NEGATION_MARKERS.filter((marker) => lower.includes(marker));
-}
-/**
-* Return the intersection of two keyword sets.
-*/
-function keywordIntersection(a, b) {
-	const result = [];
-	for (const w of a) if (b.has(w)) result.push(w);
-	return result;
-}
-/**
-* Detect contradiction pairs across all verified memory entries.
-*
-* For each verified entry:
-*   1. Find entries with >= MIN_SHARED_KEYWORDS shared keywords.
-*   2. Check for negation markers in one but not the other.
-*   3. If contradiction detected: create 'contradicts' graph edges.
-*   4. Lower quality score of the contradicted (lower quality) entry by 0.15.
-*
-* Only considers entries where invalid_at IS NULL (currently valid).
-* Short-circuits after 50 contradiction pairs to limit consolidation cost.
-*
-* @param projectRoot - Project root directory for brain.db resolution
-* @returns List of contradiction pairs found
-*/
-async function detectContradictions(projectRoot) {
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	if (!nativeDb) return [];
-	const results = [];
-	const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-	for (const { table, textCol } of [
-		{
-			table: "brain_observations",
-			textCol: "narrative"
-		},
-		{
-			table: "brain_learnings",
-			textCol: "insight"
-		},
-		{
-			table: "brain_patterns",
-			textCol: "pattern"
-		},
-		{
-			table: "brain_decisions",
-			textCol: "decision"
-		}
-	]) {
-		if (results.length >= 50) break;
-		let entries = [];
-		try {
-			entries = typedAll(nativeDb.prepare(`
-          SELECT id, COALESCE(${textCol}, '') AS text, quality_score
-          FROM ${table}
-          WHERE invalid_at IS NULL
-            AND verified = 1
-          LIMIT 200
-        `));
-		} catch {
-			continue;
-		}
-		if (entries.length < 2) continue;
-		const keywordMap = /* @__PURE__ */ new Map();
-		const negationMap = /* @__PURE__ */ new Map();
-		for (const entry of entries) {
-			keywordMap.set(entry.id, extractKeywords(entry.text));
-			negationMap.set(entry.id, findNegationMarkers(entry.text));
-		}
-		for (let i = 0; i < entries.length; i++) {
-			if (results.length >= 50) break;
-			const entryA = entries[i];
-			const keywordsA = keywordMap.get(entryA.id);
-			const negationsA = negationMap.get(entryA.id);
-			for (let j = i + 1; j < entries.length; j++) {
-				if (results.length >= 50) break;
-				const entryB = entries[j];
-				const keywordsB = keywordMap.get(entryB.id);
-				const negationsB = negationMap.get(entryB.id);
-				const shared = keywordIntersection(keywordsA, keywordsB);
-				if (shared.length < MIN_SHARED_KEYWORDS) continue;
-				const negationsOnlyInA = negationsA.filter((m) => !negationsB.includes(m));
-				const negationsOnlyInB = negationsB.filter((m) => !negationsA.includes(m));
-				if (!(negationsOnlyInA.length > 0 || negationsOnlyInB.length > 0)) continue;
-				const negMarkers = [...negationsOnlyInA, ...negationsOnlyInB];
-				const contradictedId = (entryA.quality_score ?? .5) <= (entryB.quality_score ?? .5) ? entryA.id : entryB.id;
-				contradictedId === entryA.id ? entryB.id : entryA.id;
-				results.push({
-					entryAId: entryA.id,
-					entryBId: entryB.id,
-					contradictedId,
-					table,
-					sharedKeywords: shared.slice(0, 10),
-					negationMarkers: negMarkers.slice(0, 5)
-				});
-				const nodeA = buildNodeId(table, entryA.id);
-				const nodeB = buildNodeId(table, entryB.id);
-				try {
-					nativeDb.prepare(`
-              INSERT OR IGNORE INTO brain_page_edges
-                (from_id, to_id, edge_type, weight, provenance, created_at)
-              VALUES (?, ?, 'contradicts', 0.8, 'consolidation:contradiction', ?)
-            `).run(nodeA, nodeB, now);
-					nativeDb.prepare(`
-              INSERT OR IGNORE INTO brain_page_edges
-                (from_id, to_id, edge_type, weight, provenance, created_at)
-              VALUES (?, ?, 'contradicts', 0.8, 'consolidation:contradiction', ?)
-            `).run(nodeB, nodeA, now);
-				} catch {}
-				try {
-					nativeDb.prepare(`
-              UPDATE ${table}
-              SET quality_score = MAX(0.0, COALESCE(quality_score, 0.5) - 0.15),
-                  updated_at = ?
-              WHERE id = ?
-            `).run(now, contradictedId);
-				} catch {}
-			}
-		}
-	}
-	return results;
-}
-/**
-* Build the graph node ID for a given table + entry ID combination.
-* Mirrors the convention used in graph-auto-populate.ts.
-*/
-function buildNodeId(table, entryId) {
-	return `${{
-		brain_observations: "observation",
-		brain_learnings: "learning",
-		brain_patterns: "pattern",
-		brain_decisions: "decision"
-	}[table] ?? "entry"}:${entryId}`;
-}
-/**
-* Normalize a pattern title for dedup comparison.
-* Lowercases, collapses whitespace, strips punctuation.
-*/
-function normalizePatternTitle(title) {
-	return title.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-/**
-* Collapse near-duplicate brain_patterns rows in a single consolidation pass.
-*
-* Two rows are considered near-duplicates when:
-*   - `normalize(pattern)` is identical
-*   - `peer_id` is the same
-*   - `created_at` values fall within a configurable time window (default: 3600s / 1hr)
-*
-* The oldest row (earliest `created_at`) is kept. All others are deleted after
-* their `occurrence_count` is merged into the survivor and `last_seen_at` is
-* updated to the most-recent duplicate's timestamp.
-*
-* All operations run inside a single SQLite transaction — either everything
-* succeeds or nothing changes.
-*
-* @param projectRoot - Project root directory for brain.db resolution
-* @param windowSeconds - Max seconds between rows to consider them duplicates (default 3600)
-* @returns Number of rows removed
-*
-* @task T1896
-*/
-async function dedupePatterns(projectRoot, windowSeconds = 3600) {
-	await getBrainDb(projectRoot);
-	const nativeDb = getBrainNativeDb(projectRoot);
-	if (!nativeDb) return 0;
-	const rows = typedAll(nativeDb.prepare("SELECT id, pattern, peer_id, extracted_at, COALESCE(occurrence_count, 1) AS occurrence_count FROM brain_patterns WHERE invalid_at IS NULL ORDER BY peer_id, pattern, extracted_at ASC"));
-	const groups = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = `${row.peer_id}::${normalizePatternTitle(row.pattern)}`;
-		const group = groups.get(key) ?? [];
-		group.push(row);
-		groups.set(key, group);
-	}
-	const dedupGroups = [];
-	for (const group of groups.values()) {
-		if (group.length < 2) continue;
-		const windows = [];
-		let current = [group[0]];
-		for (let i = 1; i < group.length; i++) {
-			const prev = current[current.length - 1];
-			const prevMs = new Date(prev.extracted_at).getTime();
-			const curMs = new Date(group[i].extracted_at).getTime();
-			if (Math.abs(curMs - prevMs) / 1e3 <= windowSeconds) current.push(group[i]);
-			else {
-				if (current.length >= 2) windows.push(current);
-				current = [group[i]];
-			}
-		}
-		if (current.length >= 2) windows.push(current);
-		for (const window of windows) {
-			const keeper = window[0];
-			const duplicates = window.slice(1);
-			dedupGroups.push({
-				keptId: keeper.id,
-				removedIds: duplicates.map((r) => r.id),
-				normalizedTitle: normalizePatternTitle(keeper.pattern)
-			});
-		}
-	}
-	if (dedupGroups.length === 0) return 0;
-	let totalRemoved = 0;
-	nativeDb.prepare("BEGIN").run();
-	try {
-		for (const dg of dedupGroups) {
-			const dupRows = typedAll(nativeDb.prepare(`SELECT id, pattern, peer_id, extracted_at, COALESCE(occurrence_count, 1) AS occurrence_count FROM brain_patterns WHERE id IN (${dg.removedIds.map(() => "?").join(",")})`), ...dg.removedIds);
-			const summedCount = dupRows.reduce((acc, r) => acc + r.occurrence_count, 0);
-			const latestSeenAt = dupRows.reduce((latest, r) => r.extracted_at > latest ? r.extracted_at : latest, dupRows[0]?.extracted_at ?? "");
-			nativeDb.prepare("UPDATE brain_patterns SET occurrence_count = occurrence_count + ?, last_seen_at = ? WHERE id = ?").run(summedCount, latestSeenAt, dg.keptId);
-			for (const removedId of dg.removedIds) {
-				nativeDb.prepare("DELETE FROM brain_patterns WHERE id = ?").run(removedId);
-				totalRemoved++;
-			}
-		}
-		nativeDb.prepare("COMMIT").run();
-	} catch (err) {
-		nativeDb.prepare("ROLLBACK").run();
-		throw err;
-	}
-	return totalRemoved;
-}
-
-export { dedupePatterns, detectContradictions };
-//# sourceMappingURL=brain-consolidator-JGm6mzFf.js.map

package/studio-dist/server/chunks/brain-doctor-Dc2WqVbs.js

@@ -1,311 +0,0 @@
-import { m as getBrainDb, k as getBrainNativeDb } from './sqlite-Bm5LzbPs.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './chunk-DDP5xfzh.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-
-//#region ../core/dist/memory/brain-doctor.js
-/**
-* Brain noise detector — T1262 memory-doctor (read-only, parallel to E1).
-*
-* Inspects `.cleo/brain.db` for known noise patterns without modifying any
-* data. The detector is a prerequisite for the W7 shadow-write sweep
-* (T1147 / v2026.4.132) and the M7 assert-clean gate that guards Sentient v1
-* activation (T1148 / v2026.4.133).
-*
-* **Read-only contract** — this module MUST NOT write to brain.db or any
-* other persistent store. All operations are SELECT-only. The sweep
-* (mutation) phase ships in T1147 W7 under a shadow-write envelope.
-*
-* ## Noise pattern catalogue
-*
-* | Pattern | Description | Detectable via |
-* |---------|-------------|----------------|
-* | `duplicate-content` | Entries with identical `content` hash across different IDs | SHA-256 content comparison |
-* | `missing-type` | Entries where `type` is NULL or empty string | NULL/empty check |
-* | `missing-provenance` | Entries where `provenance` is NULL (unverified source) | NULL check |
-* | `orphan-edge` | Brain graph edges pointing to non-existent nodes | JOIN gap |
-* | `low-confidence` | `confidence < 0.1` entries (near-zero signal, likely noise) | threshold check |
-* | `stale-unverified` | Unverified entries older than 90 days with zero retrieval count | age + retrieval join |
-*
-* @module memory/brain-doctor
-* @task T1262 memory-doctor detector (E1-parallel, read-only)
-* @task T1258 E1 canonical naming refactor
-* @see T1147 W7 for the mutator sweep that acts on these findings
-* @see T1148 W8 M7 gate — `cleo memory doctor --assert-clean` must exit 0 before Sentient v1
-*/
-/** Entries older than this (in days) with zero retrievals are flagged as stale. */
-var STALE_AGE_DAYS = 90;
-/** Entries with confidence below this threshold are flagged as low-confidence noise. */
-var LOW_CONFIDENCE_THRESHOLD = .1;
-/**
-* Collect sample IDs (up to 5) from a SQLite query result.
-*
-* @param rows - Array of SQLite row objects with at least an `id` field.
-* @returns Array of up to 5 id strings.
-*/
-function sampleIds(rows) {
-	return rows.slice(0, 5).map((r) => r.id ?? "unknown").filter((id) => id !== "unknown");
-}
-/**
-* Run a read-only noise scan over `.cleo/brain.db` and return a structured
-* findings report.
-*
-* This function is intentionally side-effect-free: it opens brain.db in
-* read-only mode (via `getBrainNativeDb`) and only runs SELECT queries.
-* The caller bears responsibility for surfacing or acting on the findings.
-*
-* @param projectRoot - Absolute path to the CLEO project root.
-* @returns A {@link BrainDoctorResult} describing all detected noise.
-*
-* @example
-* ```typescript
-* const result = await scanBrainNoise('/mnt/projects/cleocode');
-* if (!result.isClean) {
-*   console.warn(`Brain noise detected: ${result.findings.length} patterns`);
-*   for (const f of result.findings) {
-*     console.warn(`  ${f.pattern}: ${f.count} entries — ${f.description}`);
-*   }
-* }
-* ```
-*
-* @task T1262
-*/
-async function scanBrainNoise(projectRoot) {
-	await getBrainDb(projectRoot);
-	const db = getBrainNativeDb(projectRoot);
-	const findings = [];
-	if (!db) return {
-		totalScanned: 0,
-		findings: [],
-		isClean: true,
-		scannedAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	try {
-		const tables = [
-			"brain_observations",
-			"brain_decisions",
-			"brain_patterns",
-			"brain_learnings"
-		];
-		let totalScanned = 0;
-		for (const table of tables) try {
-			const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
-			totalScanned += row?.c ?? 0;
-		} catch {}
-		{
-			const rows = [];
-			for (const table of tables) try {
-				const res = db.prepare(`SELECT id FROM ${table} WHERE type IS NULL OR type = '' LIMIT 20`).all();
-				rows.push(...res);
-			} catch {}
-			if (rows.length > 0) findings.push({
-				pattern: "missing-type",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: "Entries with NULL or empty type field — type is required for retrieval routing."
-			});
-		}
-		{
-			const rows = [];
-			for (const table of tables) try {
-				const res = db.prepare(`SELECT id FROM ${table} WHERE provenance IS NULL LIMIT 20`).all();
-				rows.push(...res);
-			} catch {}
-			if (rows.length > 0) findings.push({
-				pattern: "missing-provenance",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: "Entries with NULL provenance — source cannot be verified for retrieval integrity."
-			});
-		}
-		{
-			const rows = [];
-			for (const table of tables) try {
-				const res = db.prepare(`SELECT id FROM ${table} WHERE confidence IS NOT NULL AND confidence < ? LIMIT 20`).all(LOW_CONFIDENCE_THRESHOLD);
-				rows.push(...res);
-			} catch {}
-			if (rows.length > 0) findings.push({
-				pattern: "low-confidence",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: `Entries with confidence < ${LOW_CONFIDENCE_THRESHOLD} — near-zero signal, likely noise.`
-			});
-		}
-		{
-			const staleThreshold = /* @__PURE__ */ new Date();
-			staleThreshold.setDate(staleThreshold.getDate() - STALE_AGE_DAYS);
-			const staleIso = staleThreshold.toISOString();
-			const rows = [];
-			for (const table of tables) try {
-				const res = db.prepare(`SELECT id FROM ${table}
-               WHERE verified = 0
-                 AND created_at < ?
-               LIMIT 20`).all(staleIso);
-				rows.push(...res);
-			} catch {}
-			if (rows.length > 0) findings.push({
-				pattern: "stale-unverified",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: `Unverified entries older than ${STALE_AGE_DAYS} days — likely outdated observations.`
-			});
-		}
-		{
-			const rows = [];
-			for (const table of tables) try {
-				const res = db.prepare(`SELECT id FROM ${table}
-               WHERE content IN (
-                 SELECT content FROM ${table}
-                 WHERE content IS NOT NULL
-                 GROUP BY content HAVING COUNT(*) > 1
-               ) LIMIT 20`).all();
-				rows.push(...res);
-			} catch {}
-			if (rows.length > 0) findings.push({
-				pattern: "duplicate-content",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: "Entries sharing identical content — duplicates inflate retrieval scores."
-			});
-		}
-		try {
-			const rows = db.prepare(`SELECT e.id FROM brain_edges e
-             LEFT JOIN brain_nodes src ON src.id = e.source_id
-             LEFT JOIN brain_nodes tgt ON tgt.id = e.target_id
-             WHERE src.id IS NULL OR tgt.id IS NULL
-             LIMIT 20`).all();
-			if (rows.length > 0) findings.push({
-				pattern: "orphan-edge",
-				count: rows.length,
-				sampleIds: sampleIds(rows),
-				description: "Brain graph edges pointing to non-existent nodes — referential integrity violation."
-			});
-		} catch {}
-		const autoExtractHealth = computeAutoExtractHealth(db);
-		const provenanceDistribution = computeProvenanceDistribution(db);
-		return {
-			totalScanned,
-			findings,
-			isClean: findings.length === 0,
-			scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			autoExtractHealth,
-			provenanceDistribution
-		};
-	} catch {
-		return {
-			totalScanned: 0,
-			findings: [],
-			isClean: true,
-			scannedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
-}
-/**
-* Compute auto-extract pipeline health from a live brain.db connection.
-*
-* Queries observation/learning counts plus brain_promotion_log fulfillment stats.
-* Returns undefined when the required tables are not available.
-*
-* @param db - Native database instance from getBrainNativeDb (accepts DatabaseSync or compatible)
-*/
-function computeAutoExtractHealth(db) {
-	if (!db) return void 0;
-	const nativeDb = db;
-	try {
-		const observationCount = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_observations WHERE invalid_at IS NULL`).get()?.cnt ?? 0;
-		const learningCount = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_learnings WHERE invalid_at IS NULL`).get()?.cnt ?? 0;
-		let pendingPromotions = 0;
-		let fulfilledPromotions = 0;
-		try {
-			pendingPromotions = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_promotion_log WHERE fulfilled_at IS NULL`).get()?.cnt ?? 0;
-			fulfilledPromotions = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_promotion_log WHERE fulfilled_at IS NOT NULL`).get()?.cnt ?? 0;
-		} catch {}
-		let lastConsolidationAt = null;
-		try {
-			lastConsolidationAt = nativeDb.prepare(`SELECT started_at FROM brain_consolidation_events ORDER BY started_at DESC LIMIT 1`).get()?.started_at ?? null;
-		} catch {}
-		const extractionRatio = observationCount > 0 ? learningCount / observationCount : 1;
-		return {
-			observationCount,
-			learningCount,
-			pendingPromotions,
-			fulfilledPromotions,
-			extractionRatio,
-			lastConsolidationAt,
-			healthy: observationCount === 0 || extractionRatio >= .01
-		};
-	} catch {
-		return;
-	}
-}
-/**
-* Compute provenance distribution counts from brain_observations.
-*
-* Returns counts by origin value, validated_at non-null count, and provenance_chain non-null count.
-* Returns undefined when the columns do not exist (pre-T1897 database).
-*/
-function computeProvenanceDistribution(db) {
-	if (!db) return void 0;
-	const nativeDb = db;
-	try {
-		const total = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_observations WHERE invalid_at IS NULL`).get()?.cnt ?? 0;
-		const byOrigin = {};
-		try {
-			const rows = nativeDb.prepare(`SELECT COALESCE(origin, '__null__') AS origin_val, COUNT(*) AS cnt
-           FROM brain_observations WHERE invalid_at IS NULL
-           GROUP BY origin_val`).all();
-			for (const row of rows) byOrigin[row.origin_val === "__null__" ? "(unset)" : row.origin_val] = row.cnt;
-		} catch {}
-		let verifiedCount = 0;
-		try {
-			verifiedCount = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_observations WHERE invalid_at IS NULL AND validated_at IS NOT NULL`).get()?.cnt ?? 0;
-		} catch {}
-		let derivedCount = 0;
-		try {
-			derivedCount = nativeDb.prepare(`SELECT COUNT(*) AS cnt FROM brain_observations WHERE invalid_at IS NULL AND provenance_chain IS NOT NULL`).get()?.cnt ?? 0;
-		} catch {}
-		return {
-			total,
-			byOrigin,
-			verifiedCount,
-			derivedCount
-		};
-	} catch {
-		return;
-	}
-}
-
-export { scanBrainNoise };
-//# sourceMappingURL=brain-doctor-Dc2WqVbs.js.map