@duckcodeailabs/dql-project 1.6.18 → 1.6.19

package/dist/local-notebook-research-storage.js

@@ -0,0 +1,1521 @@
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { mkdirSync } from 'node:fs';
+const require = createRequire(import.meta.url);
+let databaseCtor = null;
+const HAS_SQL_SQL = "(COALESCE(NULLIF(TRIM(reviewed_sql), ''), NULLIF(TRIM(generated_sql), '')) IS NOT NULL)";
+const HAS_REVIEWED_SQL = "(NULLIF(TRIM(reviewed_sql), '') IS NOT NULL)";
+const HAS_GENERATED_SQL = "(NULLIF(TRIM(generated_sql), '') IS NOT NULL)";
+const HAS_PREVIEW_SQL = "(result_preview IS NOT NULL AND TRIM(result_preview) <> '')";
+const HAS_DRAFT_SQL = "(draft_block_path IS NOT NULL AND TRIM(draft_block_path) <> '')";
+const HAS_EVIDENCE_SQL = "((evidence IS NOT NULL AND TRIM(evidence) <> '' AND TRIM(evidence) <> 'null') OR (context_pack_id IS NOT NULL AND TRIM(context_pack_id) <> ''))";
+const DRAFT_READY_SQL = `(TRIM(question) <> '' AND ${HAS_REVIEWED_SQL} AND ${HAS_EVIDENCE_SQL} AND status <> 'error')`;
+const CERTIFICATION_READY_SQL = `(${DRAFT_READY_SQL} AND ${HAS_PREVIEW_SQL} AND ${HAS_DRAFT_SQL} AND COALESCE(dql_promotion_action, '') NOT IN ('reuse_existing', 'review_required'))`;
+const BLOCKED_SQL = `(status = 'error' OR TRIM(question) = '' OR NOT ${HAS_SQL_SQL})`;
+const NEXT_ACTION_SQL = `CASE
+  WHEN review_status IN ('completed', 'rejected', 'certified') THEN 'continue_review'
+  WHEN ${BLOCKED_SQL} THEN 'fix_blockers'
+  WHEN NOT ${HAS_REVIEWED_SQL} AND ${HAS_GENERATED_SQL} THEN 'review_sql'
+  WHEN NOT ${HAS_EVIDENCE_SQL} THEN 'review_context'
+  WHEN NOT ${HAS_PREVIEW_SQL} THEN 'run_preview'
+  WHEN dql_promotion_action = 'reuse_existing' THEN 'reuse_existing'
+  WHEN NOT ${HAS_DRAFT_SQL} AND ${DRAFT_READY_SQL} THEN 'create_dql_draft'
+  WHEN ${CERTIFICATION_READY_SQL} THEN 'open_certification'
+  WHEN ${HAS_DRAFT_SQL} THEN 'complete_review'
+  ELSE 'continue_review'
+END`;
+const NEXT_ACTION_PRIORITY_SQL = `CASE (${NEXT_ACTION_SQL})
+  WHEN 'fix_blockers' THEN 0
+  WHEN 'review_sql' THEN 1
+  WHEN 'review_context' THEN 2
+  WHEN 'run_preview' THEN 3
+  WHEN 'reuse_existing' THEN 4
+  WHEN 'create_dql_draft' THEN 5
+  WHEN 'open_certification' THEN 6
+  WHEN 'complete_review' THEN 7
+  WHEN 'continue_review' THEN 8
+  ELSE 9
+END`;
+const SEARCH_INDEX_VERSION = '3';
+const RESEARCH_DOMAIN_GROUP_LIMIT = 100;
+const RESEARCH_INTENT_GROUP_LIMIT = 50;
+const RESEARCH_NOTEBOOK_GROUP_LIMIT = 100;
+const RESEARCH_OWNER_GROUP_LIMIT = 100;
+function loadDatabase() {
+    databaseCtor ??= require('better-sqlite3');
+    return databaseCtor;
+}
+const NOTEBOOK_NEXT_ACTION_PRIORITY = [
+    'fix_blockers',
+    'review_sql',
+    'review_context',
+    'run_preview',
+    'reuse_existing',
+    'create_dql_draft',
+    'open_certification',
+    'complete_review',
+    'continue_review',
+];
+function notebookSummaryNextAction(counts) {
+    for (const action of NOTEBOOK_NEXT_ACTION_PRIORITY) {
+        const count = counts[action];
+        if (count > 0)
+            return { action, count };
+    }
+    return undefined;
+}
+function actionCountsFromRow(row) {
+    return {
+        fix_blockers: row.nextFixBlockers ?? 0,
+        review_sql: row.nextReviewSql ?? 0,
+        review_context: row.nextReviewContext ?? 0,
+        run_preview: row.nextRunPreview ?? 0,
+        reuse_existing: row.nextReuseExisting ?? 0,
+        create_dql_draft: row.nextCreateDqlDraft ?? 0,
+        open_certification: row.nextOpenCertification ?? 0,
+        complete_review: row.nextCompleteReview ?? 0,
+        continue_review: row.nextContinueReview ?? 0,
+    };
+}
+export function defaultNotebookResearchDbPath(projectRoot) {
+    return `${projectRoot}/.dql/local/notebook-research.sqlite`;
+}
+export class LocalNotebookResearchStorage {
+    db;
+    searchIndexAvailable = false;
+    constructor(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const Database = loadDatabase();
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.initSchema();
+    }
+    close() {
+        this.db.close();
+    }
+    createRun(input) {
+        const now = new Date().toISOString();
+        const question = cleanOptionalString(input.question) ?? 'Notebook research';
+        const sourceCell = normalizeSourceCellInput(input.sourceCell);
+        const sourceSql = sourceCell?.sql ?? sourceCell?.content ?? sourceCell?.source;
+        const run = {
+            id: input.id ?? `nbr_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            notebookPath: input.notebookPath,
+            domain: cleanOptionalString(input.domain) ?? inferResearchDomain({
+                context: input.context,
+                notebookPath: input.notebookPath,
+            }),
+            owner: cleanOptionalString(input.owner),
+            sourceCellId: cleanOptionalString(input.sourceCellId) ?? sourceCell?.id,
+            sourceCellName: cleanOptionalString(input.sourceCellName) ?? sourceCell?.name,
+            sourceCellFingerprint: cleanOptionalString(input.sourceCellFingerprint)
+                ?? sourceCell?.fingerprint
+                ?? fingerprintSql(cleanOptionalString(input.reviewedSql) ?? cleanOptionalString(input.generatedSql) ?? sourceSql),
+            title: cleanOptionalString(input.title) ?? titleFromQuestion(question),
+            question,
+            intent: input.intent ?? inferIntent(question),
+            context: input.context,
+            status: 'draft',
+            generatedSql: cleanOptionalString(input.generatedSql),
+            reviewedSql: cleanOptionalString(input.reviewedSql),
+            warnings: [],
+            reviewStatus: 'needs_review',
+            dqlCandidateIds: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db.prepare(`
+      INSERT INTO notebook_research_runs (
+        id, notebook_path, domain, owner, source_cell_id, source_cell_name, source_cell_fingerprint, title, question,
+        intent, context, status, summary, recommendation, result_preview,
+        evidence, research_plan, generated_sql, reviewed_sql, display, context_pack_id,
+        route_decision, warnings, review_status, error, draft_block_path,
+        dql_import_id, dql_candidate_ids, dql_promotion_action, dql_promotion, created_at, updated_at, last_run_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(run.id, run.notebookPath, run.domain ?? null, run.owner ?? null, run.sourceCellId ?? null, run.sourceCellName ?? null, run.sourceCellFingerprint ?? null, run.title, run.question, run.intent, json(run.context), run.status, null, null, null, null, null, run.generatedSql ?? null, run.reviewedSql ?? null, null, null, null, json(run.warnings), run.reviewStatus, null, null, null, json(run.dqlCandidateIds), null, null, run.createdAt, run.updatedAt, null);
+        this.upsertSearchIndex(run);
+        return run;
+    }
+    listRuns(query) {
+        return this.listRunsPage(query).runs;
+    }
+    listRunsPage(query) {
+        const normalized = normalizeListQuery(query);
+        const { whereSql, params } = researchListWhere(normalized, { useSearchIndex: this.searchIndexAvailable });
+        const countScope = { ...normalized, status: undefined, reviewStatus: undefined, promotionAction: undefined, readiness: undefined, age: undefined, nextAction: undefined };
+        const { whereSql: countWhereSql, params: countParams } = researchListWhere(countScope, { useSearchIndex: this.searchIndexAvailable });
+        const domainScope = { ...countScope, domain: undefined };
+        const { whereSql: domainWhereSql, params: domainParams } = researchListWhere(domainScope, { useSearchIndex: this.searchIndexAvailable });
+        const ownerScope = { ...countScope, owner: undefined };
+        const { whereSql: ownerWhereSql, params: ownerParams } = researchListWhere(ownerScope, { useSearchIndex: this.searchIndexAvailable });
+        const intentScope = { ...countScope, intent: undefined };
+        const { whereSql: intentWhereSql, params: intentParams } = researchListWhere(intentScope, { useSearchIndex: this.searchIndexAvailable });
+        const notebookScope = { ...countScope, notebookPath: undefined };
+        const { whereSql: notebookWhereSql, params: notebookParams } = researchListWhere(notebookScope, { useSearchIndex: this.searchIndexAvailable });
+        const groupCounts = this.db.prepare(`
+      SELECT
+        (SELECT COUNT(*) FROM (
+          SELECT COALESCE(NULLIF(TRIM(domain), ''), 'uncategorized') AS domain
+          FROM notebook_research_runs
+          ${domainWhereSql}
+          GROUP BY COALESCE(NULLIF(TRIM(domain), ''), 'uncategorized')
+        )) AS domains,
+        (SELECT COUNT(*) FROM (
+          SELECT intent
+          FROM notebook_research_runs
+          ${intentWhereSql}
+          GROUP BY intent
+        )) AS intents,
+        (SELECT COUNT(*) FROM (
+          SELECT COALESCE(NULLIF(TRIM(owner), ''), 'unassigned') AS owner
+          FROM notebook_research_runs
+          ${ownerWhereSql}
+          GROUP BY COALESCE(NULLIF(TRIM(owner), ''), 'unassigned')
+        )) AS owners,
+        (SELECT COUNT(*) FROM (
+          SELECT notebook_path
+          FROM notebook_research_runs
+          ${notebookWhereSql}
+          GROUP BY notebook_path
+        )) AS notebooks
+    `).get(...domainParams, ...intentParams, ...ownerParams, ...notebookParams);
+        const total = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM notebook_research_runs
+      ${whereSql}
+    `).get(...params)?.count ?? 0;
+        const staleCutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const expiredCutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+        const counts = this.db.prepare(`
+      SELECT
+        COUNT(*) AS total,
+        SUM(CASE WHEN status = 'ready' THEN 1 ELSE 0 END) AS ready,
+        SUM(CASE WHEN review_status = 'needs_review' THEN 1 ELSE 0 END) AS needsReview,
+        SUM(CASE WHEN review_status = 'draft_created' THEN 1 ELSE 0 END) AS dqlDrafts,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) AS errors,
+        SUM(CASE WHEN dql_promotion_action = 'reuse_existing' THEN 1 ELSE 0 END) AS reuseExisting,
+        SUM(CASE WHEN dql_promotion_action = 'extend_existing' THEN 1 ELSE 0 END) AS extendExisting,
+        SUM(CASE WHEN dql_promotion_action = 'create_replacement' THEN 1 ELSE 0 END) AS replacements,
+        SUM(CASE WHEN dql_promotion_action = 'create_new' THEN 1 ELSE 0 END) AS createNew,
+        SUM(CASE WHEN ${DRAFT_READY_SQL} THEN 1 ELSE 0 END) AS draftReady,
+        SUM(CASE WHEN ${CERTIFICATION_READY_SQL} THEN 1 ELSE 0 END) AS certificationReady,
+        SUM(CASE WHEN ${BLOCKED_SQL} THEN 1 ELSE 0 END) AS blocked,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpen,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpen,
+        COUNT(DISTINCT CASE WHEN source_cell_id IS NOT NULL AND TRIM(source_cell_id) <> '' THEN source_cell_id END) AS sourceLinked,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'fix_blockers' THEN 1 ELSE 0 END) AS nextFixBlockers,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_sql' THEN 1 ELSE 0 END) AS nextReviewSql,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_context' THEN 1 ELSE 0 END) AS nextReviewContext,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'run_preview' THEN 1 ELSE 0 END) AS nextRunPreview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'reuse_existing' THEN 1 ELSE 0 END) AS nextReuseExisting,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'create_dql_draft' THEN 1 ELSE 0 END) AS nextCreateDqlDraft,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'open_certification' THEN 1 ELSE 0 END) AS nextOpenCertification,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'complete_review' THEN 1 ELSE 0 END) AS nextCompleteReview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'continue_review' THEN 1 ELSE 0 END) AS nextContinueReview
+      FROM notebook_research_runs
+      ${countWhereSql}
+    `).get(staleCutoff, expiredCutoff, ...countParams);
+        const domains = this.db.prepare(`
+      SELECT
+        COALESCE(NULLIF(TRIM(domain), ''), 'uncategorized') AS domain,
+        COUNT(*) AS total,
+        SUM(CASE WHEN ${DRAFT_READY_SQL} THEN 1 ELSE 0 END) AS draftReady,
+        SUM(CASE WHEN ${CERTIFICATION_READY_SQL} THEN 1 ELSE 0 END) AS certificationReady,
+        SUM(CASE WHEN ${BLOCKED_SQL} THEN 1 ELSE 0 END) AS blocked,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpen,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpen,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'fix_blockers' THEN 1 ELSE 0 END) AS nextFixBlockers,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_sql' THEN 1 ELSE 0 END) AS nextReviewSql,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_context' THEN 1 ELSE 0 END) AS nextReviewContext,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'run_preview' THEN 1 ELSE 0 END) AS nextRunPreview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'reuse_existing' THEN 1 ELSE 0 END) AS nextReuseExisting,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'create_dql_draft' THEN 1 ELSE 0 END) AS nextCreateDqlDraft,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'open_certification' THEN 1 ELSE 0 END) AS nextOpenCertification,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'complete_review' THEN 1 ELSE 0 END) AS nextCompleteReview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'continue_review' THEN 1 ELSE 0 END) AS nextContinueReview,
+        MIN(${NEXT_ACTION_PRIORITY_SQL}) AS nextActionPriority
+      FROM notebook_research_runs
+      ${domainWhereSql}
+      GROUP BY COALESCE(NULLIF(TRIM(domain), ''), 'uncategorized')
+      ORDER BY nextActionPriority ASC, blocked DESC, certificationReady DESC, draftReady DESC, total DESC, domain ASC
+      LIMIT ${RESEARCH_DOMAIN_GROUP_LIMIT}
+    `).all(staleCutoff, expiredCutoff, ...domainParams);
+        const owners = this.db.prepare(`
+      SELECT
+        COALESCE(NULLIF(TRIM(owner), ''), 'unassigned') AS owner,
+        COUNT(*) AS total,
+        SUM(CASE WHEN ${DRAFT_READY_SQL} THEN 1 ELSE 0 END) AS draftReady,
+        SUM(CASE WHEN ${CERTIFICATION_READY_SQL} THEN 1 ELSE 0 END) AS certificationReady,
+        SUM(CASE WHEN ${BLOCKED_SQL} THEN 1 ELSE 0 END) AS blocked,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpen,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpen,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'fix_blockers' THEN 1 ELSE 0 END) AS nextFixBlockers,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_sql' THEN 1 ELSE 0 END) AS nextReviewSql,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_context' THEN 1 ELSE 0 END) AS nextReviewContext,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'run_preview' THEN 1 ELSE 0 END) AS nextRunPreview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'reuse_existing' THEN 1 ELSE 0 END) AS nextReuseExisting,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'create_dql_draft' THEN 1 ELSE 0 END) AS nextCreateDqlDraft,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'open_certification' THEN 1 ELSE 0 END) AS nextOpenCertification,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'complete_review' THEN 1 ELSE 0 END) AS nextCompleteReview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'continue_review' THEN 1 ELSE 0 END) AS nextContinueReview,
+        MIN(${NEXT_ACTION_PRIORITY_SQL}) AS nextActionPriority
+      FROM notebook_research_runs
+      ${ownerWhereSql}
+      GROUP BY COALESCE(NULLIF(TRIM(owner), ''), 'unassigned')
+      ORDER BY nextActionPriority ASC, blocked DESC, certificationReady DESC, draftReady DESC, total DESC, owner ASC
+      LIMIT ${RESEARCH_OWNER_GROUP_LIMIT}
+    `).all(staleCutoff, expiredCutoff, ...ownerParams);
+        const intents = this.db.prepare(`
+      SELECT
+        intent,
+        COUNT(*) AS total,
+        SUM(CASE WHEN ${DRAFT_READY_SQL} THEN 1 ELSE 0 END) AS draftReady,
+        SUM(CASE WHEN ${CERTIFICATION_READY_SQL} THEN 1 ELSE 0 END) AS certificationReady,
+        SUM(CASE WHEN ${BLOCKED_SQL} THEN 1 ELSE 0 END) AS blocked,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpen,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpen,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'fix_blockers' THEN 1 ELSE 0 END) AS nextFixBlockers,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_sql' THEN 1 ELSE 0 END) AS nextReviewSql,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_context' THEN 1 ELSE 0 END) AS nextReviewContext,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'run_preview' THEN 1 ELSE 0 END) AS nextRunPreview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'reuse_existing' THEN 1 ELSE 0 END) AS nextReuseExisting,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'create_dql_draft' THEN 1 ELSE 0 END) AS nextCreateDqlDraft,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'open_certification' THEN 1 ELSE 0 END) AS nextOpenCertification,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'complete_review' THEN 1 ELSE 0 END) AS nextCompleteReview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'continue_review' THEN 1 ELSE 0 END) AS nextContinueReview,
+        MIN(${NEXT_ACTION_PRIORITY_SQL}) AS nextActionPriority
+      FROM notebook_research_runs
+      ${intentWhereSql}
+      GROUP BY intent
+      ORDER BY nextActionPriority ASC, blocked DESC, certificationReady DESC, draftReady DESC, total DESC, intent ASC
+      LIMIT ${RESEARCH_INTENT_GROUP_LIMIT}
+    `).all(staleCutoff, expiredCutoff, ...intentParams);
+        const notebooks = this.db.prepare(`
+      SELECT
+        notebook_path AS path,
+        COUNT(*) AS total,
+        SUM(CASE WHEN ${DRAFT_READY_SQL} THEN 1 ELSE 0 END) AS draftReady,
+        SUM(CASE WHEN ${CERTIFICATION_READY_SQL} THEN 1 ELSE 0 END) AS certificationReady,
+        SUM(CASE WHEN ${BLOCKED_SQL} THEN 1 ELSE 0 END) AS blocked,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpen,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpen,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'fix_blockers' THEN 1 ELSE 0 END) AS nextFixBlockers,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_sql' THEN 1 ELSE 0 END) AS nextReviewSql,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'review_context' THEN 1 ELSE 0 END) AS nextReviewContext,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'run_preview' THEN 1 ELSE 0 END) AS nextRunPreview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'reuse_existing' THEN 1 ELSE 0 END) AS nextReuseExisting,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'create_dql_draft' THEN 1 ELSE 0 END) AS nextCreateDqlDraft,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'open_certification' THEN 1 ELSE 0 END) AS nextOpenCertification,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'complete_review' THEN 1 ELSE 0 END) AS nextCompleteReview,
+        SUM(CASE WHEN (${NEXT_ACTION_SQL}) = 'continue_review' THEN 1 ELSE 0 END) AS nextContinueReview,
+        MIN(${NEXT_ACTION_PRIORITY_SQL}) AS nextActionPriority
+      FROM notebook_research_runs
+      ${notebookWhereSql}
+      GROUP BY notebook_path
+      ORDER BY nextActionPriority ASC, blocked DESC, certificationReady DESC, draftReady DESC, total DESC, path ASC
+      LIMIT ${RESEARCH_NOTEBOOK_GROUP_LIMIT}
+    `).all(staleCutoff, expiredCutoff, ...notebookParams);
+        const orderSql = normalized.sort === 'priority'
+            ? `ORDER BY
+          ${NEXT_ACTION_PRIORITY_SQL} ASC,
+          updated_at DESC`
+            : 'ORDER BY updated_at DESC';
+        const pageSql = normalized.limit === undefined ? '' : 'LIMIT ? OFFSET ?';
+        const pageParams = normalized.limit === undefined ? [] : [normalized.limit, normalized.offset];
+        const rows = this.db.prepare(`
+      SELECT * FROM notebook_research_runs
+      ${whereSql}
+      ${orderSql}
+      ${pageSql}
+    `).all(...params, ...pageParams);
+        return {
+            runs: rows.map(rowToRun),
+            total,
+            domains: domains.map((row) => {
+                const nextAction = notebookSummaryNextAction(actionCountsFromRow(row));
+                return {
+                    domain: row.domain ?? 'uncategorized',
+                    total: row.total ?? 0,
+                    draftReady: row.draftReady ?? 0,
+                    certificationReady: row.certificationReady ?? 0,
+                    blocked: row.blocked ?? 0,
+                    staleOpen: row.staleOpen ?? 0,
+                    expiredOpen: row.expiredOpen ?? 0,
+                    ...(nextAction ? { nextAction: nextAction.action, nextActionCount: nextAction.count } : {}),
+                };
+            }),
+            owners: owners.map((row) => {
+                const nextAction = notebookSummaryNextAction(actionCountsFromRow(row));
+                return {
+                    owner: row.owner ?? 'unassigned',
+                    total: row.total ?? 0,
+                    draftReady: row.draftReady ?? 0,
+                    certificationReady: row.certificationReady ?? 0,
+                    blocked: row.blocked ?? 0,
+                    staleOpen: row.staleOpen ?? 0,
+                    expiredOpen: row.expiredOpen ?? 0,
+                    ...(nextAction ? { nextAction: nextAction.action, nextActionCount: nextAction.count } : {}),
+                };
+            }),
+            intents: intents.map((row) => {
+                const nextAction = notebookSummaryNextAction(actionCountsFromRow(row));
+                return {
+                    intent: parseIntent(row.intent),
+                    total: row.total ?? 0,
+                    draftReady: row.draftReady ?? 0,
+                    certificationReady: row.certificationReady ?? 0,
+                    blocked: row.blocked ?? 0,
+                    staleOpen: row.staleOpen ?? 0,
+                    expiredOpen: row.expiredOpen ?? 0,
+                    ...(nextAction ? { nextAction: nextAction.action, nextActionCount: nextAction.count } : {}),
+                };
+            }),
+            notebooks: notebooks.map((row) => {
+                const path = row.path ?? 'notebooks/untitled.dqlnb';
+                const nextAction = notebookSummaryNextAction(actionCountsFromRow(row));
+                return {
+                    path,
+                    title: notebookTitleFromPath(path),
+                    total: row.total ?? 0,
+                    draftReady: row.draftReady ?? 0,
+                    certificationReady: row.certificationReady ?? 0,
+                    blocked: row.blocked ?? 0,
+                    staleOpen: row.staleOpen ?? 0,
+                    expiredOpen: row.expiredOpen ?? 0,
+                    ...(nextAction ? { nextAction: nextAction.action, nextActionCount: nextAction.count } : {}),
+                };
+            }),
+            counts: {
+                total: counts?.total ?? 0,
+                ready: counts?.ready ?? 0,
+                needsReview: counts?.needsReview ?? 0,
+                dqlDrafts: counts?.dqlDrafts ?? 0,
+                errors: counts?.errors ?? 0,
+                reuseExisting: counts?.reuseExisting ?? 0,
+                extendExisting: counts?.extendExisting ?? 0,
+                replacements: counts?.replacements ?? 0,
+                createNew: counts?.createNew ?? 0,
+                draftReady: counts?.draftReady ?? 0,
+                certificationReady: counts?.certificationReady ?? 0,
+                blocked: counts?.blocked ?? 0,
+                staleOpen: counts?.staleOpen ?? 0,
+                expiredOpen: counts?.expiredOpen ?? 0,
+                sourceLinked: counts?.sourceLinked ?? 0,
+                nextActions: {
+                    fix_blockers: counts?.nextFixBlockers ?? 0,
+                    review_sql: counts?.nextReviewSql ?? 0,
+                    review_context: counts?.nextReviewContext ?? 0,
+                    run_preview: counts?.nextRunPreview ?? 0,
+                    reuse_existing: counts?.nextReuseExisting ?? 0,
+                    create_dql_draft: counts?.nextCreateDqlDraft ?? 0,
+                    open_certification: counts?.nextOpenCertification ?? 0,
+                    complete_review: counts?.nextCompleteReview ?? 0,
+                    continue_review: counts?.nextContinueReview ?? 0,
+                },
+            },
+            groupCounts: {
+                domains: groupCounts?.domains ?? domains.length,
+                owners: groupCounts?.owners ?? owners.length,
+                intents: groupCounts?.intents ?? intents.length,
+                notebooks: groupCounts?.notebooks ?? notebooks.length,
+            },
+            limit: normalized.limit,
+            offset: normalized.offset,
+        };
+    }
+    listLatestRunsBySourceCell(query) {
+        const notebookPath = cleanOptionalString(query.notebookPath);
+        if (!notebookPath)
+            return [];
+        const limit = typeof query.limit === 'number' && Number.isFinite(query.limit)
+            ? Math.max(1, Math.min(10_000, Math.floor(query.limit)))
+            : 10_000;
+        const sourceCells = normalizeSourceCoverageCells(query, limit);
+        const sourceCellIds = sourceCells.map((cell) => cell.id);
+        if (sourceCellIds.length === 0)
+            return [];
+        const bySourceCell = new Map();
+        const chunkSize = 400;
+        for (let index = 0; index < sourceCellIds.length; index += chunkSize) {
+            const chunk = sourceCellIds.slice(index, index + chunkSize);
+            const placeholders = chunk.map(() => '?').join(', ');
+            const rows = this.db.prepare(`
+        SELECT *
+        FROM notebook_research_runs
+        WHERE notebook_path = ?
+          AND source_cell_id IN (${placeholders})
+        ORDER BY source_cell_id ASC, updated_at DESC, rowid DESC
+      `).all(notebookPath, ...chunk);
+            for (const row of rows) {
+                const sourceCellId = optionalString(row.source_cell_id);
+                if (!sourceCellId || bySourceCell.has(sourceCellId))
+                    continue;
+                bySourceCell.set(sourceCellId, rowToRun(row));
+            }
+        }
+        const unmatchedByFingerprint = new Map();
+        for (const sourceCell of sourceCells) {
+            if (bySourceCell.has(sourceCell.id) || !sourceCell.fingerprint)
+                continue;
+            const list = unmatchedByFingerprint.get(sourceCell.fingerprint) ?? [];
+            list.push(sourceCell);
+            unmatchedByFingerprint.set(sourceCell.fingerprint, list);
+        }
+        const fingerprints = Array.from(unmatchedByFingerprint.keys());
+        for (let index = 0; index < fingerprints.length; index += chunkSize) {
+            const chunk = fingerprints.slice(index, index + chunkSize);
+            const placeholders = chunk.map(() => '?').join(', ');
+            const rows = this.db.prepare(`
+	        SELECT *
+	        FROM notebook_research_runs
+	        WHERE notebook_path = ?
+	          AND source_cell_fingerprint IN (${placeholders})
+	          AND (source_cell_id IS NULL OR TRIM(source_cell_id) = '')
+	        ORDER BY source_cell_fingerprint ASC, updated_at DESC, rowid DESC
+	      `).all(notebookPath, ...chunk);
+            const byFingerprint = new Set();
+            for (const row of rows) {
+                const fingerprint = optionalString(row.source_cell_fingerprint);
+                if (!fingerprint || byFingerprint.has(fingerprint))
+                    continue;
+                byFingerprint.add(fingerprint);
+                const sourceCellMatches = unmatchedByFingerprint.get(fingerprint) ?? [];
+                const run = rowToRun(row);
+                for (const sourceCell of sourceCellMatches) {
+                    if (bySourceCell.has(sourceCell.id))
+                        continue;
+                    bySourceCell.set(sourceCell.id, {
+                        ...run,
+                        sourceCellId: sourceCell.id,
+                        sourceCellName: run.sourceCellName ?? sourceCell.name,
+                        sourceCellFingerprint: run.sourceCellFingerprint ?? sourceCell.fingerprint,
+                    });
+                }
+            }
+        }
+        return sourceCellIds
+            .map((sourceCellId) => bySourceCell.get(sourceCellId))
+            .filter((run) => Boolean(run));
+    }
+    listLatestRunsForMissingSourceCells(query) {
+        const notebookPath = cleanOptionalString(query.notebookPath);
+        if (!notebookPath)
+            return [];
+        const limit = typeof query.limit === 'number' && Number.isFinite(query.limit)
+            ? Math.max(1, Math.min(10_000, Math.floor(query.limit)))
+            : 10_000;
+        const currentSourceIds = new Set(normalizeSourceCoverageCells(query, Number.POSITIVE_INFINITY).map((cell) => cell.id));
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM notebook_research_runs
+      WHERE notebook_path = ?
+        AND source_cell_id IS NOT NULL
+        AND TRIM(source_cell_id) <> ''
+      ORDER BY source_cell_id ASC, updated_at DESC, rowid DESC
+    `).all(notebookPath);
+        const byMissingSource = new Map();
+        for (const row of rows) {
+            const sourceCellId = optionalString(row.source_cell_id);
+            if (!sourceCellId || currentSourceIds.has(sourceCellId) || byMissingSource.has(sourceCellId))
+                continue;
+            byMissingSource.set(sourceCellId, rowToRun(row));
+            if (byMissingSource.size >= limit)
+                break;
+        }
+        return Array.from(byMissingSource.values());
+    }
+    getRun(id) {
+        const row = this.db.prepare('SELECT * FROM notebook_research_runs WHERE id = ?').get(id);
+        return row ? rowToRun(row) : null;
+    }
+    updateRun(id, input) {
+        const current = this.getRun(id);
+        if (!current)
+            return null;
+        const now = new Date().toISOString();
+        const nextPromotion = input.dqlPromotion === undefined ? current.dqlPromotion : input.dqlPromotion;
+        const nextContext = input.context === undefined ? current.context : input.context;
+        const nextDraftBlockPath = input.draftBlockPath === undefined ? current.draftBlockPath : cleanOptionalString(input.draftBlockPath);
+        const nextDomain = cleanOptionalString(input.domain)
+            ?? inferResearchDomain({
+                context: nextContext,
+                dqlPromotion: nextPromotion,
+                draftBlockPath: nextDraftBlockPath,
+                notebookPath: current.notebookPath,
+            })
+            ?? current.domain;
+        const nextPromotionAction = input.dqlPromotionAction
+            ?? normalizePromotionAction(nextPromotion?.recommendedAction)
+            ?? current.dqlPromotionAction
+            ?? normalizePromotionAction(current.dqlPromotion?.recommendedAction);
+        this.db.prepare(`
+      UPDATE notebook_research_runs
+      SET domain = ?, owner = ?, source_cell_id = ?, source_cell_name = ?, source_cell_fingerprint = ?, title = ?, question = ?,
+          intent = ?, context = ?, status = ?, summary = ?, recommendation = ?,
+          result_preview = ?, evidence = ?, research_plan = ?, generated_sql = ?, reviewed_sql = ?,
+          display = ?, context_pack_id = ?, route_decision = ?, warnings = ?,
+          review_status = ?, error = ?, draft_block_path = ?, dql_import_id = ?,
+          dql_candidate_ids = ?, dql_promotion_action = ?, dql_promotion = ?, updated_at = ?, last_run_at = ?
+      WHERE id = ?
+    `).run(nextDomain ?? null, input.owner === undefined ? (current.owner ?? null) : (cleanOptionalString(input.owner) ?? null), input.sourceCellId === undefined ? (current.sourceCellId ?? null) : (cleanOptionalString(input.sourceCellId) ?? null), input.sourceCellName === undefined ? (current.sourceCellName ?? null) : (cleanOptionalString(input.sourceCellName) ?? null), input.sourceCellFingerprint === undefined ? (current.sourceCellFingerprint ?? null) : (cleanOptionalString(input.sourceCellFingerprint) ?? null), cleanOptionalString(input.title) ?? current.title, cleanOptionalString(input.question) ?? current.question, input.intent ?? current.intent, json(nextContext), input.status ?? current.status, input.summary === undefined ? (current.summary ?? null) : (cleanOptionalString(input.summary) ?? null), input.recommendation === undefined ? (current.recommendation ?? null) : (cleanOptionalString(input.recommendation) ?? null), input.resultPreview === undefined ? json(current.resultPreview) : json(input.resultPreview), input.evidence === undefined ? json(current.evidence) : json(input.evidence), input.researchPlan === undefined ? json(current.researchPlan) : json(input.researchPlan), input.generatedSql === undefined ? (current.generatedSql ?? null) : (cleanOptionalString(input.generatedSql) ?? null), input.reviewedSql === undefined ? (current.reviewedSql ?? null) : (cleanOptionalString(input.reviewedSql) ?? null), input.display === undefined ? json(current.display) : json(input.display), input.contextPackId === undefined ? (current.contextPackId ?? null) : (cleanOptionalString(input.contextPackId) ?? null), input.routeDecision === undefined ? json(current.routeDecision) : json(input.routeDecision), input.warnings === undefined ? json(current.warnings) : json(input.warnings), input.reviewStatus ?? current.reviewStatus, input.error === undefined ? (current.error ?? null) : (cleanOptionalString(input.error) ?? null), nextDraftBlockPath ?? null, input.dqlImportId === undefined ? (current.dqlImportId ?? null) : (cleanOptionalString(input.dqlImportId) ?? null), input.dqlCandidateIds === undefined ? json(current.dqlCandidateIds) : json(input.dqlCandidateIds), nextPromotionAction ?? null, json(nextPromotion), now, input.lastRunAt === undefined ? (current.lastRunAt ?? null) : (cleanOptionalString(input.lastRunAt) ?? null), id);
+        const updated = this.getRun(id);
+        if (updated)
+            this.upsertSearchIndex(updated);
+        return updated;
+    }
+    markPromoted(id, input) {
+        return this.updateRun(id, {
+            reviewStatus: 'draft_created',
+            draftBlockPath: input.draftBlockPath,
+            dqlImportId: input.dqlImportId,
+            dqlCandidateIds: input.dqlCandidateIds,
+            dqlPromotionAction: normalizePromotionAction(input.dqlPromotion?.recommendedAction),
+            dqlPromotion: input.dqlPromotion,
+        });
+    }
+    seedRunsFromCells(input) {
+        const notebookPath = cleanOptionalString(input.notebookPath);
+        if (!notebookPath)
+            return { created: [], createdCount: 0, skippedCount: input.cells.length, limitApplied: false };
+        const limit = typeof input.limit === 'number' && Number.isFinite(input.limit)
+            ? Math.max(1, Math.min(1000, Math.floor(input.limit)))
+            : 1000;
+        const cells = Array.isArray(input.cells) ? input.cells : [];
+        const existingSourceIds = new Set(this.db.prepare(`
+	        SELECT source_cell_id AS sourceCellId
+	        FROM notebook_research_runs
+	        WHERE notebook_path = ? AND source_cell_id IS NOT NULL AND TRIM(source_cell_id) <> ''
+      `).all(notebookPath)
+            .map((row) => cleanOptionalString(row.sourceCellId))
+            .filter((id) => Boolean(id)));
+        const existingSourceFingerprints = new Set(this.db.prepare(`
+	        SELECT source_cell_fingerprint AS sourceCellFingerprint
+	        FROM notebook_research_runs
+	        WHERE notebook_path = ? AND source_cell_fingerprint IS NOT NULL AND TRIM(source_cell_fingerprint) <> ''
+	      `).all(notebookPath)
+            .map((row) => cleanOptionalString(row.sourceCellFingerprint))
+            .filter((fingerprint) => Boolean(fingerprint)));
+        const created = [];
+        let skippedCount = Math.max(0, cells.length - limit);
+        for (const cell of cells.slice(0, limit)) {
+            const sourceCell = normalizeSourceCellInput(cell.sourceCell);
+            const sourceCellId = cleanOptionalString(cell.id) ?? cleanOptionalString(cell.sourceCellId) ?? sourceCell?.id;
+            const sql = cleanOptionalString(cell.sql) ?? cleanOptionalString(cell.content) ?? cleanOptionalString(cell.source) ?? sourceCell?.sql ?? sourceCell?.content ?? sourceCell?.source;
+            const sourceCellFingerprint = cleanOptionalString(cell.sourceCellFingerprint) ?? sourceCell?.fingerprint ?? fingerprintSql(sql);
+            if (!sourceCellId
+                || !sql
+                || existingSourceIds.has(sourceCellId)
+                || Boolean(sourceCellFingerprint && existingSourceFingerprints.has(sourceCellFingerprint))) {
+                skippedCount += 1;
+                continue;
+            }
+            const sourceCellName = cleanOptionalString(cell.name) ?? cleanOptionalString(cell.sourceCellName) ?? cleanOptionalString(cell.title) ?? sourceCell?.name ?? sourceCellId;
+            const question = cleanOptionalString(cell.question) ?? seedQuestionForCell(sourceCellName);
+            const run = this.createRun({
+                notebookPath,
+                domain: cleanOptionalString(input.domain),
+                owner: cleanOptionalString(input.owner),
+                sourceCellId,
+                sourceCellName,
+                title: cleanOptionalString(cell.title) ?? sourceCellName,
+                question,
+                intent: parseOptionalIntent(cell.intent),
+                context: {
+                    notebookTitle: cleanOptionalString(input.notebookTitle),
+                    sourceCell: {
+                        id: sourceCellId,
+                        name: sourceCellName,
+                        type: cleanOptionalString(cell.type) ?? sourceCell?.type,
+                    },
+                    selectedDomain: cleanOptionalString(input.domain),
+                    selectedOwner: cleanOptionalString(input.owner),
+                    seededFromNotebook: true,
+                },
+                sourceCellFingerprint,
+                generatedSql: sql,
+                reviewedSql: sql,
+            });
+            existingSourceIds.add(sourceCellId);
+            if (sourceCellFingerprint)
+                existingSourceFingerprints.add(sourceCellFingerprint);
+            created.push(run);
+        }
+        return {
+            created,
+            createdCount: created.length,
+            skippedCount,
+            limitApplied: cells.length > limit,
+        };
+    }
+    getDiagnostics() {
+        const staleThresholdDays = 7;
+        const expiredThresholdDays = 30;
+        const staleCutoff = new Date(Date.now() - staleThresholdDays * 24 * 60 * 60 * 1000).toISOString();
+        const expiredCutoff = new Date(Date.now() - expiredThresholdDays * 24 * 60 * 60 * 1000).toISOString();
+        const counts = this.db.prepare(`
+      SELECT
+        COUNT(*) AS totalRuns,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') THEN 1 ELSE 0 END) AS activeRuns,
+        SUM(CASE WHEN review_status IN ('completed', 'certified', 'rejected') THEN 1 ELSE 0 END) AS closedRuns,
+        COUNT(DISTINCT notebook_path) AS notebooks,
+        COUNT(DISTINCT COALESCE(NULLIF(TRIM(domain), ''), 'uncategorized')) AS domains,
+        COUNT(DISTINCT COALESCE(NULLIF(TRIM(owner), ''), 'unassigned')) AS owners,
+        COUNT(CASE WHEN source_cell_id IS NOT NULL AND TRIM(source_cell_id) <> '' THEN 1 END) AS sourceLinkedRuns,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS staleOpenRuns,
+        SUM(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') AND updated_at <= ? THEN 1 ELSE 0 END) AS expiredOpenRuns,
+        MIN(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') THEN updated_at END) AS oldestOpenUpdatedAt,
+        MAX(CASE WHEN review_status NOT IN ('completed', 'certified', 'rejected') THEN updated_at END) AS newestOpenUpdatedAt,
+        MIN(updated_at) AS oldestUpdatedAt,
+        MAX(updated_at) AS newestUpdatedAt
+      FROM notebook_research_runs
+    `).get(staleCutoff, expiredCutoff);
+        const totalRuns = counts?.totalRuns ?? 0;
+        const indexRows = this.searchIndexAvailable
+            ? this.scalarCount('SELECT COUNT(*) AS count FROM notebook_research_runs_fts')
+            : 0;
+        const indexVersion = this.searchIndexAvailable
+            ? this.getMeta('notebook_research_search_index_version')
+            : undefined;
+        const stale = this.searchIndexAvailable
+            ? indexRows !== totalRuns || indexVersion !== SEARCH_INDEX_VERSION
+            : false;
+        const warnings = [];
+        if (!this.searchIndexAvailable) {
+            warnings.push('Full-text search index is unavailable; research search falls back to local text scanning.');
+        }
+        else if (stale) {
+            warnings.push('Research search index is stale and will rebuild on the next storage initialization.');
+        }
+        if (totalRuns > 10_000) {
+            warnings.push('Research backlog is above 10,000 runs; use project, domain, next-action, and search filters before reviewing.');
+        }
+        if ((counts?.activeRuns ?? 0) > 500) {
+            warnings.push('Open research backlog is large; use Open next, next-action filters, and register snapshots for review handoff.');
+        }
+        if ((counts?.expiredOpenRuns ?? 0) > 0) {
+            warnings.push(`${counts?.expiredOpenRuns ?? 0} open research run(s) have not changed in ${expiredThresholdDays}+ days; revalidate or close stale investigations.`);
+        }
+        else if ((counts?.staleOpenRuns ?? 0) > 0) {
+            warnings.push(`${counts?.staleOpenRuns ?? 0} open research run(s) have not changed in ${staleThresholdDays}+ days; confirm they are still relevant.`);
+        }
+        return {
+            counts: {
+                totalRuns,
+                activeRuns: counts?.activeRuns ?? 0,
+                closedRuns: counts?.closedRuns ?? 0,
+                notebooks: counts?.notebooks ?? 0,
+                domains: counts?.domains ?? 0,
+                owners: counts?.owners ?? 0,
+                sourceLinkedRuns: counts?.sourceLinkedRuns ?? 0,
+            },
+            health: {
+                staleOpenRuns: counts?.staleOpenRuns ?? 0,
+                expiredOpenRuns: counts?.expiredOpenRuns ?? 0,
+                staleThresholdDays,
+                expiredThresholdDays,
+                oldestOpenUpdatedAt: optionalString(counts?.oldestOpenUpdatedAt),
+                newestOpenUpdatedAt: optionalString(counts?.newestOpenUpdatedAt),
+            },
+            search: {
+                indexed: this.searchIndexAvailable,
+                indexRows,
+                indexVersion,
+                stale,
+            },
+            updatedAt: {
+                oldest: optionalString(counts?.oldestUpdatedAt),
+                newest: optionalString(counts?.newestUpdatedAt),
+            },
+            limits: {
+                pageSize: 25,
+                maxPageSize: 500,
+                sourceCoverageLimit: 10_000,
+                seedCellLimit: 1_000,
+            },
+            warnings,
+        };
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS notebook_research_runs (
+        id TEXT PRIMARY KEY,
+        notebook_path TEXT NOT NULL,
+        domain TEXT,
+        owner TEXT,
+        source_cell_id TEXT,
+        source_cell_name TEXT,
+        source_cell_fingerprint TEXT,
+        title TEXT NOT NULL,
+        question TEXT NOT NULL,
+        intent TEXT NOT NULL,
+        context TEXT,
+        status TEXT NOT NULL,
+        summary TEXT,
+        recommendation TEXT,
+        result_preview TEXT,
+        evidence TEXT,
+        research_plan TEXT,
+        generated_sql TEXT,
+        reviewed_sql TEXT,
+        display TEXT,
+        context_pack_id TEXT,
+        route_decision TEXT,
+        warnings TEXT,
+        review_status TEXT NOT NULL,
+        error TEXT,
+        draft_block_path TEXT,
+        dql_import_id TEXT,
+        dql_candidate_ids TEXT,
+        dql_promotion_action TEXT,
+        dql_promotion TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        last_run_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_notebook_research_path ON notebook_research_runs(notebook_path, updated_at);
+      CREATE INDEX IF NOT EXISTS idx_notebook_research_review ON notebook_research_runs(review_status);
+	      CREATE INDEX IF NOT EXISTS idx_notebook_research_status ON notebook_research_runs(status);
+	      CREATE INDEX IF NOT EXISTS idx_notebook_research_intent ON notebook_research_runs(intent, updated_at);
+	      CREATE INDEX IF NOT EXISTS idx_notebook_research_source_cell ON notebook_research_runs(notebook_path, source_cell_id, updated_at);
+	      CREATE INDEX IF NOT EXISTS idx_notebook_research_source_fingerprint ON notebook_research_runs(notebook_path, source_cell_fingerprint, updated_at);
+
+      CREATE TABLE IF NOT EXISTS notebook_research_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+        this.ensureColumn('notebook_research_runs', 'dql_promotion_action', 'TEXT');
+        this.ensureColumn('notebook_research_runs', 'dql_promotion', 'TEXT');
+        this.ensureColumn('notebook_research_runs', 'domain', 'TEXT');
+        this.ensureColumn('notebook_research_runs', 'owner', 'TEXT');
+        this.ensureColumn('notebook_research_runs', 'source_cell_fingerprint', 'TEXT');
+        this.ensureColumn('notebook_research_runs', 'research_plan', 'TEXT');
+        this.backfillDomains();
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_notebook_research_promotion_action ON notebook_research_runs(dql_promotion_action)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_notebook_research_domain ON notebook_research_runs(domain, updated_at)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_notebook_research_source_fingerprint ON notebook_research_runs(notebook_path, source_cell_fingerprint, updated_at)');
+        this.initSearchIndex();
+    }
+    ensureColumn(table, column, definition) {
+        const rows = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        if (rows.some((row) => row.name === column))
+            return;
+        this.db.prepare(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`).run();
+    }
+    backfillDomains() {
+        const rows = this.db.prepare(`
+      SELECT id, notebook_path, context, draft_block_path, dql_promotion
+      FROM notebook_research_runs
+      WHERE domain IS NULL OR TRIM(domain) = ''
+    `).all();
+        const update = this.db.prepare('UPDATE notebook_research_runs SET domain = ? WHERE id = ?');
+        for (const row of rows) {
+            const domain = inferResearchDomain({
+                context: parseJson(row.context),
+                dqlPromotion: parseDqlPromotion(parseJson(row.dql_promotion)),
+                draftBlockPath: optionalString(row.draft_block_path),
+                notebookPath: optionalString(row.notebook_path),
+            });
+            if (domain)
+                update.run(domain, row.id);
+        }
+    }
+    initSearchIndex() {
+        try {
+            this.dropSearchIndexIfMissingColumn('owner');
+            this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS notebook_research_runs_fts USING fts5(
+          id UNINDEXED,
+          notebook_path,
+          domain,
+          owner,
+          source_cell_name,
+          title,
+          question,
+          intent,
+          summary,
+          recommendation,
+          warnings,
+          draft_block_path,
+          dql_promotion_action,
+          generated_sql,
+          reviewed_sql,
+          context_text,
+          evidence_text,
+          research_plan_text,
+          promotion_text,
+          tokenize = 'unicode61'
+        );
+      `);
+            this.searchIndexAvailable = true;
+            this.ensureSearchIndexFresh();
+        }
+        catch {
+            this.searchIndexAvailable = false;
+        }
+    }
+    ensureSearchIndexFresh() {
+        if (!this.searchIndexAvailable)
+            return;
+        const version = this.getMeta('notebook_research_search_index_version');
+        const runCount = this.scalarCount('SELECT COUNT(*) AS count FROM notebook_research_runs');
+        const indexCount = this.scalarCount('SELECT COUNT(*) AS count FROM notebook_research_runs_fts');
+        if (version === SEARCH_INDEX_VERSION && runCount === indexCount)
+            return;
+        this.rebuildSearchIndex();
+    }
+    rebuildSearchIndex() {
+        if (!this.searchIndexAvailable)
+            return;
+        this.db.prepare('DELETE FROM notebook_research_runs_fts').run();
+        const rows = this.db.prepare('SELECT * FROM notebook_research_runs ORDER BY rowid ASC').all();
+        const insert = this.searchIndexInsertStatement();
+        const transaction = this.db.transaction((items) => {
+            for (const row of items) {
+                insert.run(...searchIndexValues(rowToRun(row)));
+            }
+        });
+        transaction(rows);
+        this.setMeta('notebook_research_search_index_version', SEARCH_INDEX_VERSION);
+    }
+    upsertSearchIndex(run) {
+        if (!this.searchIndexAvailable)
+            return;
+        try {
+            this.db.prepare('DELETE FROM notebook_research_runs_fts WHERE id = ?').run(run.id);
+            this.searchIndexInsertStatement().run(...searchIndexValues(run));
+            this.setMeta('notebook_research_search_index_version', SEARCH_INDEX_VERSION);
+        }
+        catch {
+            this.searchIndexAvailable = false;
+        }
+    }
+    searchIndexInsertStatement() {
+        return this.db.prepare(`
+      INSERT INTO notebook_research_runs_fts (
+        id, notebook_path, domain, owner, source_cell_name, title, question, intent, summary, recommendation,
+        warnings, draft_block_path, dql_promotion_action, generated_sql, reviewed_sql,
+        context_text, evidence_text, research_plan_text, promotion_text
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    }
+    dropSearchIndexIfMissingColumn(column) {
+        const exists = this.db.prepare(`
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table' AND name = 'notebook_research_runs_fts'
+    `).get();
+        if (!exists)
+            return;
+        const rows = this.db.prepare('PRAGMA table_info(notebook_research_runs_fts)').all();
+        if (rows.some((row) => row.name === column))
+            return;
+        this.db.prepare('DROP TABLE notebook_research_runs_fts').run();
+    }
+    scalarCount(sql) {
+        return this.db.prepare(sql).get()?.count ?? 0;
+    }
+    getMeta(key) {
+        return optionalString(this.db.prepare('SELECT value FROM notebook_research_meta WHERE key = ?').get(key)?.value);
+    }
+    setMeta(key, value) {
+        this.db.prepare(`
+      INSERT INTO notebook_research_meta (key, value)
+      VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(key, value);
+    }
+}
+function rowToRun(row) {
+    return {
+        id: String(row.id),
+        notebookPath: String(row.notebook_path),
+        domain: optionalString(row.domain) ?? inferResearchDomain({
+            context: parseJson(row.context),
+            dqlPromotion: parseDqlPromotion(parseJson(row.dql_promotion)),
+            draftBlockPath: optionalString(row.draft_block_path),
+            notebookPath: optionalString(row.notebook_path),
+        }),
+        owner: optionalString(row.owner),
+        sourceCellId: optionalString(row.source_cell_id),
+        sourceCellName: optionalString(row.source_cell_name),
+        sourceCellFingerprint: optionalString(row.source_cell_fingerprint),
+        title: String(row.title),
+        question: String(row.question),
+        intent: parseIntent(row.intent),
+        context: parseJson(row.context),
+        status: parseStatus(row.status),
+        summary: optionalString(row.summary),
+        recommendation: optionalString(row.recommendation),
+        resultPreview: parseJson(row.result_preview),
+        evidence: parseJson(row.evidence),
+        researchPlan: parseResearchPlan(parseJson(row.research_plan)),
+        generatedSql: optionalString(row.generated_sql),
+        reviewedSql: optionalString(row.reviewed_sql),
+        display: parseJson(row.display),
+        contextPackId: optionalString(row.context_pack_id),
+        routeDecision: parseJson(row.route_decision),
+        warnings: stringArray(parseJson(row.warnings)),
+        reviewStatus: parseReviewStatus(row.review_status),
+        error: optionalString(row.error),
+        draftBlockPath: optionalString(row.draft_block_path),
+        dqlImportId: optionalString(row.dql_import_id),
+        dqlCandidateIds: stringArray(parseJson(row.dql_candidate_ids)),
+        dqlPromotionAction: normalizePromotionAction(row.dql_promotion_action),
+        dqlPromotion: parseDqlPromotion(parseJson(row.dql_promotion)),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+        lastRunAt: optionalString(row.last_run_at),
+    };
+}
+function inferIntent(question) {
+    const lower = question.toLowerCase();
+    if (/\b(trust|rely|certif|lineage|owner|caveat|gap)\b/.test(lower))
+        return 'trust_gap_review';
+    if (/\b(anomal|exception|outlier|spike|dip)\b/.test(lower))
+        return 'anomaly_investigation';
+    if (/\b(compare|versus| vs |segment|cohort)\b/.test(lower))
+        return 'segment_compare';
+    if (/\b(why|changed|change|drop|decline|increase|decrease|month|week|quarter)\b/.test(lower))
+        return 'diagnose_change';
+    if (/\b(driver|drove|break down|breakdown|contribute|top mover|movers)\b/.test(lower))
+        return 'driver_breakdown';
+    if (/\b(profile|detail|drill|customer|account|user|client|merchant|product|player|team)\b/.test(lower))
+        return 'entity_drilldown';
+    return 'ad_hoc_analysis';
+}
+function parseIntent(value) {
+    if (value === 'ad_hoc_analysis'
+        || value === 'diagnose_change'
+        || value === 'driver_breakdown'
+        || value === 'segment_compare'
+        || value === 'entity_drilldown'
+        || value === 'anomaly_investigation'
+        || value === 'trust_gap_review')
+        return value;
+    return 'ad_hoc_analysis';
+}
+function notebookTitleFromPath(path) {
+    const file = path.split(/[\\/]/).pop() ?? path;
+    return file
+        .replace(/\.dqlnb$/i, '')
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        || 'Untitled notebook';
+}
+function parseOptionalIntent(value) {
+    if (value === 'ad_hoc_analysis'
+        || value === 'diagnose_change'
+        || value === 'driver_breakdown'
+        || value === 'segment_compare'
+        || value === 'entity_drilldown'
+        || value === 'anomaly_investigation'
+        || value === 'trust_gap_review')
+        return value;
+    return undefined;
+}
+function parseStatus(value) {
+    return value === 'running' || value === 'ready' || value === 'error' ? value : 'draft';
+}
+function parseReviewStatus(value) {
+    return value === 'draft_created' || value === 'completed' || value === 'certified' || value === 'rejected' ? value : 'needs_review';
+}
+function normalizePromotionAction(value) {
+    return value === 'reuse_existing'
+        || value === 'extend_existing'
+        || value === 'create_replacement'
+        || value === 'create_new'
+        || value === 'review_required'
+        ? value
+        : undefined;
+}
+function normalizeReadinessFilter(value) {
+    return value === 'draft_ready' || value === 'certification_ready' || value === 'blocked' ? value : undefined;
+}
+function normalizeAgeFilter(value) {
+    return value === 'stale_open' || value === 'expired_open' ? value : undefined;
+}
+function normalizeNextActionFilter(value) {
+    return value === 'fix_blockers'
+        || value === 'review_sql'
+        || value === 'review_context'
+        || value === 'run_preview'
+        || value === 'reuse_existing'
+        || value === 'create_dql_draft'
+        || value === 'open_certification'
+        || value === 'complete_review'
+        || value === 'continue_review'
+        ? value
+        : undefined;
+}
+function normalizeSort(value) {
+    return value === 'updated_desc' ? 'updated_desc' : 'priority';
+}
+function titleFromQuestion(question) {
+    const clean = question.replace(/\s+/g, ' ').trim();
+    return clean.length > 80 ? `${clean.slice(0, 77)}...` : clean || 'Notebook research';
+}
+function seedQuestionForCell(sourceCellName) {
+    const cleanName = sourceCellName.replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+    return `What reusable business logic does ${cleanName || 'this query'} represent, and should it become a DQL block?`;
+}
+function normalizeSourceCellInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const source = value;
+    const id = cleanOptionalString(source.id)
+        ?? cleanOptionalString(source.sourceCellId)
+        ?? cleanOptionalString(source.cellId);
+    const name = cleanOptionalString(source.name)
+        ?? cleanOptionalString(source.sourceCellName)
+        ?? cleanOptionalString(source.title);
+    const fingerprint = cleanOptionalString(source.fingerprint)
+        ?? cleanOptionalString(source.sourceCellFingerprint)
+        ?? cleanOptionalString(source.sqlFingerprint);
+    const type = cleanOptionalString(source.type);
+    const sql = cleanOptionalString(source.sql);
+    const content = cleanOptionalString(source.content);
+    const sourceText = cleanOptionalString(source.source);
+    if (!id && !name && !fingerprint && !type && !sql && !content && !sourceText)
+        return null;
+    return { id, name, fingerprint, type, sql, content, source: sourceText };
+}
+function normalizeSourceCoverageCells(query, limit) {
+    const byId = new Map();
+    for (const id of Array.isArray(query.sourceCellIds) ? query.sourceCellIds : []) {
+        const cleanId = cleanOptionalString(id);
+        if (cleanId && !byId.has(cleanId))
+            byId.set(cleanId, { id: cleanId });
+    }
+    for (const rawCell of Array.isArray(query.sourceCells) ? query.sourceCells : []) {
+        const sourceCell = normalizeSourceCellInput(rawCell);
+        const id = sourceCell?.id;
+        if (!id)
+            continue;
+        const current = byId.get(id) ?? { id };
+        byId.set(id, {
+            id,
+            name: current.name ?? sourceCell.name,
+            fingerprint: current.fingerprint ?? sourceCell.fingerprint,
+        });
+    }
+    return Array.from(byId.values()).slice(0, limit);
+}
+function fingerprintSql(sql) {
+    const normalized = sql?.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return undefined;
+    let hash = 2166136261;
+    for (let index = 0; index < normalized.length; index += 1) {
+        hash ^= normalized.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `fnv1a:${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+function normalizeListQuery(query) {
+    if (typeof query === 'string') {
+        return { notebookPath: cleanOptionalString(query), offset: 0 };
+    }
+    const limit = typeof query?.limit === 'number' && Number.isFinite(query.limit)
+        ? Math.max(1, Math.min(500, Math.floor(query.limit)))
+        : undefined;
+    const offset = typeof query?.offset === 'number' && Number.isFinite(query.offset)
+        ? Math.max(0, Math.floor(query.offset))
+        : 0;
+    return {
+        notebookPath: cleanOptionalString(query?.notebookPath),
+        sourceCellId: cleanOptionalString(query?.sourceCellId),
+        domain: cleanOptionalString(query?.domain),
+        owner: cleanOptionalString(query?.owner),
+        intent: parseOptionalIntent(query?.intent),
+        search: cleanOptionalString(query?.search),
+        status: query?.status,
+        reviewStatus: query?.reviewStatus,
+        promotionAction: normalizePromotionAction(query?.promotionAction),
+        readiness: normalizeReadinessFilter(query?.readiness),
+        age: normalizeAgeFilter(query?.age),
+        nextAction: normalizeNextActionFilter(query?.nextAction),
+        activeOnly: query?.activeOnly === true,
+        sort: normalizeSort(query?.sort),
+        limit,
+        offset,
+    };
+}
+function researchListWhere(query, options = {}) {
+    const clauses = [];
+    const params = [];
+    if (query.notebookPath) {
+        clauses.push('notebook_path = ?');
+        params.push(query.notebookPath);
+    }
+    if (query.sourceCellId) {
+        clauses.push('source_cell_id = ?');
+        params.push(query.sourceCellId);
+    }
+    if (query.domain) {
+        if (query.domain.toLowerCase() === 'uncategorized') {
+            clauses.push("(domain IS NULL OR TRIM(domain) = '')");
+        }
+        else {
+            clauses.push('LOWER(domain) = ?');
+            params.push(query.domain.toLowerCase());
+        }
+    }
+    if (query.owner) {
+        clauses.push('LOWER(owner) = ?');
+        params.push(query.owner.toLowerCase());
+    }
+    if (query.intent) {
+        clauses.push('intent = ?');
+        params.push(query.intent);
+    }
+    if (query.status) {
+        clauses.push('status = ?');
+        params.push(query.status);
+    }
+    if (query.reviewStatus) {
+        clauses.push('review_status = ?');
+        params.push(query.reviewStatus);
+    }
+    if (query.activeOnly) {
+        clauses.push("review_status NOT IN ('completed', 'certified', 'rejected')");
+    }
+    if (query.promotionAction) {
+        clauses.push('dql_promotion_action = ?');
+        params.push(query.promotionAction);
+    }
+    if (query.readiness === 'draft_ready') {
+        clauses.push(`(${DRAFT_READY_SQL})`);
+    }
+    else if (query.readiness === 'certification_ready') {
+        clauses.push(`(${CERTIFICATION_READY_SQL})`);
+    }
+    else if (query.readiness === 'blocked') {
+        clauses.push(`(${BLOCKED_SQL})`);
+    }
+    if (query.age === 'stale_open' || query.age === 'expired_open') {
+        const thresholdDays = query.age === 'expired_open' ? 30 : 7;
+        const cutoff = new Date(Date.now() - thresholdDays * 24 * 60 * 60 * 1000).toISOString();
+        clauses.push("review_status NOT IN ('completed', 'certified', 'rejected')");
+        clauses.push('updated_at <= ?');
+        params.push(cutoff);
+    }
+    if (query.nextAction) {
+        clauses.push(`(${NEXT_ACTION_SQL}) = ?`);
+        params.push(query.nextAction);
+    }
+    if (query.search) {
+        const ftsQuery = options.useSearchIndex ? searchIndexQuery(query.search) : undefined;
+        if (ftsQuery) {
+            clauses.push(`id IN (
+        SELECT id
+        FROM notebook_research_runs_fts
+        WHERE notebook_research_runs_fts MATCH ?
+      )`);
+            params.push(ftsQuery);
+        }
+        else {
+            const fallback = researchSearchFallback(query.search);
+            clauses.push(fallback.sql);
+            params.push(...fallback.params);
+        }
+    }
+    return {
+        whereSql: clauses.length ? `WHERE ${clauses.join(' AND ')}` : '',
+        params,
+    };
+}
+function searchIndexQuery(search) {
+    const tokens = researchSearchTokens(search);
+    if (!tokens?.length)
+        return undefined;
+    return tokens.map((token) => `${token}*`).join(' AND ');
+}
+function researchSearchTokens(search) {
+    const tokens = search
+        .toLowerCase()
+        .match(/[a-z0-9]+/g)
+        ?.filter((token) => token.length >= 2)
+        .slice(0, 12) ?? [];
+    return Array.from(new Set(tokens));
+}
+const RESEARCH_SEARCH_FALLBACK_FIELDS = [
+    'LOWER(title)',
+    'LOWER(question)',
+    "LOWER(COALESCE(domain, ''))",
+    "LOWER(COALESCE(owner, ''))",
+    'LOWER(intent)',
+    "LOWER(COALESCE(source_cell_id, ''))",
+    "LOWER(COALESCE(source_cell_name, ''))",
+    "LOWER(COALESCE(source_cell_fingerprint, ''))",
+    'LOWER(notebook_path)',
+    "LOWER(COALESCE(summary, ''))",
+    "LOWER(COALESCE(recommendation, ''))",
+    "LOWER(COALESCE(warnings, ''))",
+    "LOWER(COALESCE(draft_block_path, ''))",
+    "LOWER(COALESCE(dql_promotion_action, ''))",
+    "LOWER(COALESCE(generated_sql, ''))",
+    "LOWER(COALESCE(reviewed_sql, ''))",
+    "LOWER(COALESCE(context, ''))",
+    "LOWER(COALESCE(result_preview, ''))",
+    "LOWER(COALESCE(evidence, ''))",
+    "LOWER(COALESCE(research_plan, ''))",
+    "LOWER(COALESCE(context_pack_id, ''))",
+    "LOWER(COALESCE(route_decision, ''))",
+    "LOWER(COALESCE(display, ''))",
+    "LOWER(COALESCE(dql_import_id, ''))",
+    "LOWER(COALESCE(dql_candidate_ids, ''))",
+    "LOWER(COALESCE(dql_promotion, ''))",
+    "LOWER(COALESCE(error, ''))",
+];
+function researchSearchFallback(search) {
+    const terms = researchSearchTokens(search);
+    const needles = terms.length ? terms : [search.trim().toLowerCase()].filter(Boolean);
+    const clauses = needles.map(() => `(${RESEARCH_SEARCH_FALLBACK_FIELDS.map((field) => `${field} LIKE ? ESCAPE '\\'`).join(' OR ')})`);
+    return {
+        sql: `(${clauses.join(' AND ')})`,
+        params: needles.flatMap((term) => RESEARCH_SEARCH_FALLBACK_FIELDS.map(() => `%${escapeLike(term)}%`)),
+    };
+}
+function escapeLike(value) {
+    return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+function searchIndexValues(run) {
+    return [
+        run.id,
+        run.notebookPath,
+        run.domain ?? '',
+        run.owner ?? '',
+        run.sourceCellName ?? '',
+        run.title,
+        run.question,
+        run.intent,
+        run.summary ?? '',
+        run.recommendation ?? '',
+        run.warnings.join(' '),
+        run.draftBlockPath ?? '',
+        run.dqlPromotionAction ?? '',
+        run.generatedSql ?? '',
+        run.reviewedSql ?? '',
+        searchTextFromValue({
+            sourceCellId: run.sourceCellId,
+            sourceCellFingerprint: run.sourceCellFingerprint,
+            context: run.context,
+            resultPreview: run.resultPreview,
+            display: run.display,
+        }),
+        searchTextFromValue({
+            evidence: run.evidence,
+            contextPackId: run.contextPackId,
+            routeDecision: run.routeDecision,
+            error: run.error,
+        }),
+        searchTextFromValue(run.researchPlan),
+        searchTextFromValue(run.dqlPromotion),
+    ];
+}
+function searchTextFromValue(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string')
+        return value.slice(0, 20_000);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    try {
+        return JSON.stringify(value).slice(0, 20_000);
+    }
+    catch {
+        return '';
+    }
+}
+function cleanOptionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function inferResearchDomain(input) {
+    const contextDomain = domainFromContext(input.context);
+    if (contextDomain)
+        return contextDomain;
+    const promotedDomain = input.dqlPromotion?.candidates.find((candidate) => candidate.domain)?.domain;
+    if (promotedDomain)
+        return cleanOptionalString(promotedDomain);
+    const draftDomain = domainFromPath(input.draftBlockPath);
+    if (draftDomain)
+        return draftDomain;
+    return domainFromPath(input.notebookPath);
+}
+function domainFromContext(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    return cleanOptionalString(record.selectedDomain)
+        ?? cleanOptionalString(record.domain)
+        ?? domainFromContext(record.block)
+        ?? domainFromContext(record.notebook)
+        ?? domainFromContext(record.metadata);
+}
+function domainFromPath(path) {
+    if (!path)
+        return undefined;
+    const domainLayout = path.match(/(?:^|\/)domains\/([^/]+)/);
+    if (domainLayout?.[1])
+        return cleanOptionalString(domainLayout[1]);
+    const draftLayout = path.match(/(?:^|\/)_drafts\/([^/]+)/);
+    if (draftLayout?.[1])
+        return cleanOptionalString(draftLayout[1]);
+    return undefined;
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function json(value) {
+    return value === undefined ? null : JSON.stringify(value);
+}
+function parseJson(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function parseDqlPromotion(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const importId = optionalString(record.importId);
+    if (!importId)
+        return undefined;
+    return {
+        importId,
+        candidateIds: stringArray(record.candidateIds),
+        draftBlockPath: optionalString(record.draftBlockPath),
+        recommendedAction: optionalString(record.recommendedAction),
+        similarityMatches: parsePromotionMatches(record.similarityMatches),
+        candidates: parsePromotionCandidates(record.candidates),
+        createdAt: optionalString(record.createdAt) ?? new Date(0).toISOString(),
+    };
+}
+function parsePromotionCandidates(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            return [];
+        const record = item;
+        const id = optionalString(record.id);
+        const name = optionalString(record.name);
+        if (!id || !name)
+            return [];
+        return [{
+                id,
+                name,
+                domain: optionalString(record.domain),
+                draftPath: optionalString(record.draftPath),
+                savedPath: optionalString(record.savedPath),
+                reviewStatus: optionalString(record.reviewStatus),
+                recommendedAction: optionalString(record.recommendedAction),
+                similarityMatches: parsePromotionMatches(record.similarityMatches),
+                parameterPolicy: parseParameterPolicy(record.parameterPolicy),
+                allowedFilters: stringArray(record.allowedFilters),
+                warnings: stringArray(record.warnings),
+            }];
+    });
+}
+function parsePromotionMatches(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            return [];
+        const record = item;
+        const name = optionalString(record.name);
+        const reason = optionalString(record.reason);
+        if (!name || !reason)
+            return [];
+        const score = typeof record.score === 'number' && Number.isFinite(record.score) ? record.score : 0;
+        return [{
+                kind: optionalString(record.kind) ?? 'near_variant',
+                objectKey: optionalString(record.objectKey),
+                name,
+                status: optionalString(record.status),
+                source: optionalString(record.source),
+                score,
+                reason,
+                recommendedAction: optionalString(record.recommendedAction) ?? 'review_required',
+            }];
+    });
+}
+function parseParameterPolicy(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            return [];
+        const record = item;
+        const name = optionalString(record.name);
+        const policy = optionalString(record.policy);
+        return name && policy ? [{ name, policy }] : [];
+    });
+}
+function parseResearchPlan(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const evidence = record.evidence && typeof record.evidence === 'object' && !Array.isArray(record.evidence)
+        ? record.evidence
+        : {};
+    const preview = record.preview && typeof record.preview === 'object' && !Array.isArray(record.preview)
+        ? record.preview
+        : {};
+    const promotion = record.promotion && typeof record.promotion === 'object' && !Array.isArray(record.promotion)
+        ? record.promotion
+        : {};
+    const sqlState = record.sqlState === 'generated' || record.sqlState === 'reviewed' ? record.sqlState : 'missing';
+    const previewStatus = preview.status === 'ready' || preview.status === 'error' ? preview.status : 'not_run';
+    const promotionPath = parseResearchPlanPromotionPath(promotion.path);
+    const rowCount = typeof preview.rowCount === 'number' && Number.isFinite(preview.rowCount) ? preview.rowCount : undefined;
+    return {
+        sqlState,
+        grain: optionalString(record.grain),
+        parameterPolicy: parseParameterPolicy(record.parameterPolicy),
+        allowedFilters: stringArray(record.allowedFilters),
+        evidence: {
+            trustLabel: optionalString(evidence.trustLabel),
+            contextPackId: optionalString(evidence.contextPackId),
+            evidenceCount: finiteNumber(evidence.evidenceCount),
+            relationCount: finiteNumber(evidence.relationCount),
+            missingContextCount: finiteNumber(evidence.missingContextCount),
+        },
+        preview: {
+            status: previewStatus,
+            ...(rowCount === undefined ? {} : { rowCount }),
+        },
+        promotion: {
+            path: promotionPath,
+            duplicateDecision: optionalString(promotion.duplicateDecision),
+        },
+        reviewFocus: stringArray(record.reviewFocus),
+        generatedAt: optionalString(record.generatedAt) ?? new Date(0).toISOString(),
+    };
+}
+function parseResearchPlanPromotionPath(value) {
+    return value === 'review_context'
+        || value === 'run_preview'
+        || value === 'reuse_existing'
+        || value === 'create_dql_draft'
+        || value === 'open_certification'
+        || value === 'complete_review'
+        ? value
+        : 'needs_sql';
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+//# sourceMappingURL=local-notebook-research-storage.js.map