@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/exodus-BBuuN6aA.js

@@ -1,2594 +0,0 @@
-import { y as resolveCleoDir, b as getLogger, g as getCleoHome } from './paths-CV7S5-Zm.js';
-import { r as resolveDualScopeDbPath, o as openDualScopeDbAtPath } from './dual-scope-db-DKnWu1KM.js';
-import { g as getCleoVersion } from './on-open-Wpcw7DV4.js';
-import { o as openCleoDbSnapshot } from './open-cleo-db--8sYNaYY.js';
-import { createRequire } from 'node:module';
-import { existsSync, unlinkSync, mkdirSync, copyFileSync, statSync, statfsSync, readdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { join } from '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:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import 'node:fs/promises';
-import './index-61916rmV.js';
-
-//#region ../core/dist/store/exodus/table-name-map.js
-/**
-* Deterministic legacy-to-consolidated table-name resolver for exodus migration.
-*
-* ## Problem (ROOT CAUSE 1 — T11532)
-*
-* Legacy source DBs use UNPREFIXED table names (`tasks`, `messages`, `skills`, …)
-* while the consolidated dual-scope `cleo.db` uses DOMAIN-PREFIXED names
-* (`tasks_tasks`, `conduit_messages`, `skills_skills`, …). Without a mapping,
-* every `INSERT OR IGNORE INTO main."<name>"` silently copies 0 rows because the
-* target table is absent under the legacy name.
-*
-* ## Design
-*
-* The mapping is a static lookup table derived from reading every
-* `cleo-project/` and `cleo-global/` schema file and matching the physical
-* `sqliteTable('<consolidated-name>', …)` names against each legacy DB's schema.
-*
-* Rules:
-*  - If a legacy table is already domain-prefixed in the consolidated schema
-*    (e.g. `brain_observations`, `nexus_audit_log`, `tasks_goal`), map identity.
-*  - If a legacy table has NO consolidated counterpart (virtual tables, orphan
-*    telemetry tables, …), return `null` so the caller can log + skip explicitly
-*    rather than silently discarding rows.
-*
-* ## Source-DB scope
-*
-* The resolver takes a `sourceName` (the `LegacyDbDescriptor.name` value, e.g.
-* `"tasks"`, `"brain (project)"`, `"conduit"`) to disambiguate tables that
-* share the same legacy name across multiple DBs (e.g. `"attachments"` lives in
-* both conduit.db and attachments.ts/tasks.db; `"sessions"` lives in both
-* tasks.db and signaldock.db).
-*
-* ## Nexus code-graph residency move (ADR-090 · T11539)
-*
-* The four nexus code-graph tables — `nexus_nodes`, `nexus_relations`,
-* `nexus_contracts`, `nexus_code_index` (ADR-090 "Category A") — were removed
-* from the GLOBAL schema (`../schema/cleo-global/nexus.ts`) and now reside in
-* PROJECT scope (`../schema/cleo-project/nexus-graph.ts`). They are still
-* extracted from the legacy GLOBAL `nexus.db` source, but exodus MUST route them
-* into the PROJECT-scope consolidated `cleo.db`, not the global one. The source
-* descriptor `nexus` carries `targetScope: 'global'`, so a per-table scope
-* override is required for these four tables — see
-* {@link NEXUS_GRAPH_PROJECT_TABLES} and {@link resolveTableTargetScope}. The
-* six registry/identity tables (`nexus_project_registry`,
-* `nexus_project_id_aliases`, `nexus_audit_log`, `nexus_schema_meta`,
-* `nexus_user_profile`, `nexus_sigils`) stay GLOBAL.
-*
-* @task T11532 (ROOT CAUSE 1 — name-mapping gap)
-* @task T11533 (ROOT CAUSE 3 — signaldock skills mapping + brain_release_links skip +
-*               brain_session_narrative mapping)
-* @task T11546 (no-home-table fixes — schema_meta→tasks_schema_meta, brain_usage_log mapping,
-*               brain_schema_meta mapping)
-* @task T11539 (nexus code-graph residency — route the 4 graph tables to PROJECT scope)
-* @epic T11248
-* @saga T11242
-*/
-/**
-* tasks.db — tables from tasks-schema.ts (tasks.ts, audit.ts, background-jobs.ts,
-* chain-schema.ts, agent-schema.ts, lifecycle.ts, evidence-bindings.ts,
-* experiments.ts, attachments.ts, manifest.ts, code-index.ts, playbooks.ts,
-* provenance/releases.ts, provenance/commits.ts, provenance/pull-requests.ts,
-* goal.ts) all prefixed with `tasks_` in the consolidated schema, except the
-* docs tables which become `docs_*`.
-*/
-var TASKS_DB_MAP = new Map([
-	["tasks", "tasks_tasks"],
-	["task_acceptance_criteria", "tasks_task_acceptance_criteria"],
-	["acceptance_projection_state", "tasks_acceptance_projection_state"],
-	["acceptance_projection_dirty", "tasks_acceptance_projection_dirty"],
-	["task_dependencies", "tasks_task_dependencies"],
-	["task_labels", "tasks_task_labels"],
-	["task_relations", "tasks_task_relations"],
-	["sessions", "tasks_sessions"],
-	["session_handoff_entries", "tasks_session_handoff_entries"],
-	["task_work_history", "tasks_task_work_history"],
-	["task_acceptance_criteria_history", "tasks_task_acceptance_criteria_history"],
-	["external_task_links", "tasks_external_task_links"],
-	["audit_log", "tasks_audit_log"],
-	["token_usage", "tasks_token_usage"],
-	["architecture_decisions", "tasks_architecture_decisions"],
-	["adr_task_links", "tasks_adr_task_links"],
-	["adr_relations", "tasks_adr_relations"],
-	["status_registry", "tasks_status_registry"],
-	["background_jobs", "tasks_background_jobs"],
-	["warp_chains", "tasks_warp_chains"],
-	["warp_chain_instances", "tasks_warp_chain_instances"],
-	["agent_instances", "tasks_agent_instances"],
-	["agent_error_log", "tasks_agent_error_log"],
-	["lifecycle_pipelines", "tasks_lifecycle_pipelines"],
-	["lifecycle_stages", "tasks_lifecycle_stages"],
-	["lifecycle_gate_results", "tasks_lifecycle_gate_results"],
-	["lifecycle_evidence", "tasks_lifecycle_evidence"],
-	["lifecycle_transitions", "tasks_lifecycle_transitions"],
-	["evidence_ac_bindings", "tasks_evidence_ac_bindings"],
-	["experiments", "tasks_experiments"],
-	["attachments", "docs_attachments"],
-	["attachment_refs", "docs_attachment_refs"],
-	["manifest_entries", "docs_manifest_entries"],
-	["pipeline_manifest", "docs_pipeline_manifest"],
-	["commits", "tasks_commits"],
-	["task_commits", "tasks_task_commits"],
-	["commit_files", "tasks_commit_files"],
-	["pull_requests", "tasks_pull_requests"],
-	["pr_commits", "tasks_pr_commits"],
-	["pr_tasks", "tasks_pr_tasks"],
-	["releases", "tasks_releases"],
-	["release_commits", "tasks_release_commits"],
-	["release_changes", "tasks_release_changes"],
-	["release_changesets", "tasks_release_changesets"],
-	["release_artifacts", "tasks_release_artifacts"],
-	["playbook_runs", "tasks_playbook_runs"],
-	["playbook_approvals", "tasks_playbook_approvals"],
-	["tasks_goal", "tasks_goal"],
-	["schema_meta", "tasks_schema_meta"],
-	["agent_credentials", "tasks_agent_credentials"],
-	["brain_release_links", "tasks_brain_release_links"]
-]);
-/**
-* brain.db (project) and global brain.db — tables from memory-schema.ts /
-* cleo-shared/brain.ts.
-*
-* Most tables are already `brain_*` prefixed in the legacy schema and keep the
-* same name in the consolidated schema. Three exceptions:
-*   - `sticky_tags`        → `brain_sticky_tags` (lost prefix in legacy)
-*   - `deriver_queue`      → `brain_deriver_queue` (lost prefix in legacy)
-*   - `session_narrative`  → `brain_session_narrative` (lost prefix in legacy)
-*
-* Tables present in the live DB but NOT in the consolidated target schema
-* (virtual tables, orphan telemetry, etc.) map to `null` — they will be
-* logged as explicit skips rather than silently discarded.
-*
-* ## brain_release_links (T11533 → T11549 → T11550 fix)
-*
-* T11533 incorrectly marked `brain_release_links` as `null` (skip). T11549 added
-* the target table `tasks_brain_release_links` to `cleo-project/provenance-orphans.ts`
-* and mapped the table here in BRAIN_DB_MAP — but T11550 discovered that the 8 rows
-* physically live in **tasks.db**, not brain.db (verified via sqlite_master). The
-* correct mapping belongs in TASKS_DB_MAP (added there in T11550). The BRAIN_DB_MAP
-* entry is now `null` (skip) to guard against double-migration if brain.db ever
-* contains a phantom table by this name.
-*
-* ## agent_credentials (T11549 → T11550 fix)
-*
-* Same situation as brain_release_links: the 3 rows physically live in **tasks.db**,
-* not brain.db. T11549 added the target table and mapped it here in BRAIN_DB_MAP,
-* but the source is tasks.db. T11550 moves the mapping to TASKS_DB_MAP and sets
-* this entry to `null` (skip) to prevent double-migration.
-*/
-var BRAIN_DB_MAP = new Map([
-	["brain_decisions", "brain_decisions"],
-	["brain_patterns", "brain_patterns"],
-	["brain_learnings", "brain_learnings"],
-	["brain_observations", "brain_observations"],
-	["brain_sticky_notes", "brain_sticky_notes"],
-	["brain_attention", "brain_attention"],
-	["brain_memory_links", "brain_memory_links"],
-	["brain_page_nodes", "brain_page_nodes"],
-	["brain_page_edges", "brain_page_edges"],
-	["brain_retrieval_log", "brain_retrieval_log"],
-	["brain_plasticity_events", "brain_plasticity_events"],
-	["brain_weight_history", "brain_weight_history"],
-	["brain_modulators", "brain_modulators"],
-	["brain_consolidation_events", "brain_consolidation_events"],
-	["brain_transcript_events", "brain_transcript_events"],
-	["brain_promotion_log", "brain_promotion_log"],
-	["brain_backfill_runs", "brain_backfill_runs"],
-	["brain_memory_trees", "brain_memory_trees"],
-	["brain_observations_staging", "brain_observations_staging"],
-	["brain_release_links", null],
-	["brain_schema_meta", "brain_schema_meta"],
-	["sticky_tags", "brain_sticky_tags"],
-	["deriver_queue", "brain_deriver_queue"],
-	["session_narrative", "brain_session_narrative"],
-	["brain_usage_log", "brain_usage_log"],
-	["brain_task_observations", null],
-	["brain_embeddings", null],
-	["brain_embeddings_info", null],
-	["agent_credentials", null]
-]);
-/**
-* conduit.db — tables from conduit-schema.ts, all prefixed `conduit_*`.
-*
-* Note: conduit.db also has an `attachments` table (conduit attachment tracking),
-* which maps to `conduit_attachments` — NOT `docs_attachments` (that is from
-* tasks.db/attachments.ts).
-*/
-var CONDUIT_DB_MAP = new Map([
-	["messages", "conduit_messages"],
-	["delivery_jobs", "conduit_delivery_jobs"],
-	["dead_letters", "conduit_dead_letters"],
-	["message_pins", "conduit_message_pins"],
-	["attachments", "conduit_attachments"],
-	["attachment_versions", "conduit_attachment_versions"],
-	["attachment_approvals", "conduit_attachment_approvals"],
-	["attachment_contributors", "conduit_attachment_contributors"],
-	["topics", "conduit_topics"],
-	["topic_subscriptions", "conduit_topic_subscriptions"],
-	["topic_messages", "conduit_topic_messages"],
-	["topic_message_acks", "conduit_topic_message_acks"],
-	["conversations", "conduit_conversations"],
-	["project_agent_refs", "conduit_project_agent_refs"]
-]);
-/**
-* nexus.db — tables from nexus-schema.ts.
-*
-* Some tables are ALREADY prefixed (`nexus_audit_log`, `nexus_nodes`, etc.) and
-* map identity. Others lack the prefix and gain `nexus_` in consolidated.
-*
-* ## Scope split (ADR-090 · T11539)
-*
-* The legacy `nexus.db` source descriptor carries `targetScope: 'global'`, but
-* the four code-graph tables (`code_index`/`nexus_code_index`, `nexus_nodes`,
-* `nexus_relations`, `nexus_contracts`) now live in PROJECT scope. Their
-* consolidated NAME is unchanged (identity / `nexus_code_index`), but their
-* destination DB is the PROJECT `cleo.db` — see {@link NEXUS_GRAPH_PROJECT_TABLES}
-* and {@link resolveTableTargetScope}. The remaining six registry/identity
-* tables stay GLOBAL.
-*/
-var NEXUS_DB_MAP = new Map([
-	["project_registry", "nexus_project_registry"],
-	["project_id_aliases", "nexus_project_id_aliases"],
-	["user_profile", "nexus_user_profile"],
-	["sigils", "nexus_sigils"],
-	["code_index", "nexus_code_index"],
-	["nexus_audit_log", "nexus_audit_log"],
-	["nexus_nodes", "nexus_nodes"],
-	["nexus_relations", "nexus_relations"],
-	["nexus_relation_weights", "nexus_relation_weights"],
-	["nexus_contracts", "nexus_contracts"],
-	["nexus_schema_meta", "nexus_schema_meta"]
-]);
-/**
-* Legacy table names of the four nexus code-graph tables that moved from GLOBAL
-* to PROJECT scope (ADR-090 · T11538/T11539).
-*
-* Keyed by the LEGACY physical name as it appears in `nexus.db`:
-*   - `nexus_nodes`, `nexus_relations`, `nexus_contracts` — already prefixed.
-*   - `code_index` — bare in legacy `nexus.db`; → `nexus_code_index` consolidated.
-*
-* Membership drives {@link resolveTableTargetScope}: exodus copies/verifies
-* these against the PROJECT consolidated `cleo.db`, NOT the GLOBAL one, even
-* though the `nexus` source descriptor's `targetScope` is `'global'`.
-*
-* @task T11539
-* @epic T11248
-* @saga T11242
-* @see cleo docs fetch adr-090-nexus-graph-residency-split
-*/
-var NEXUS_GRAPH_PROJECT_TABLES = new Set([
-	"nexus_nodes",
-	"nexus_relations",
-	"nexus_contracts",
-	"code_index"
-]);
-/**
-* Resolve the consolidated TARGET SCOPE for a legacy source table.
-*
-* Most tables share the scope of their source DB descriptor (`sourceScope`).
-* The exception is the four nexus code-graph tables — they are extracted from
-* the GLOBAL legacy `nexus.db` but land in PROJECT scope per ADR-090 (T11539).
-*
-* This is the SSoT consumed by BOTH the exodus migrate runner (insert target DB)
-* and the exodus verifier (verify target DB) so the two never disagree.
-*
-* @param sourceName  - `LegacyDbDescriptor.name` (e.g. `"nexus"`, `"tasks"`).
-* @param legacyTable - Physical table name in the legacy source DB.
-* @param sourceScope - The source descriptor's `targetScope`.
-* @returns The scope of the consolidated `cleo.db` this table copies into.
-*
-* @task T11539
-* @epic T11248
-* @saga T11242
-*/
-function resolveTableTargetScope(sourceName, legacyTable, sourceScope) {
-	if (inferSourceKind(sourceName) === "nexus" && NEXUS_GRAPH_PROJECT_TABLES.has(legacyTable)) return "project";
-	return sourceScope;
-}
-/**
-* agent-registry (global) — the legacy on-disk source file is `signaldock.db`
-* (the source-descriptor `name` stays `"signaldock"` — see {@link inferSourceKind} —
-* because that is the genuine artifact name on disk). Its bare tables map to the
-* consolidated PREFIXED `agent_registry_*` tables (renamed from `signaldock_*`
-* under T11622 / SG-AGENT-IDENTITY E4).
-*
-* KEYS are the bare legacy names (the source DB still has the old shape); VALUES
-* are the consolidated `agent_registry_*` target names — these MUST equal the
-* `sqliteTable` names declared in `cleo-global/agent-registry.ts` (asserted by
-* the exodus-map invariant test, the DHQ-046 N→0 deficit catcher).
-*
-* Note: the legacy `signaldock.db` has a `sessions` table (identity session
-* management), which maps to `agent_registry_sessions` — NOT `tasks_sessions`.
-*
-* ## `skills` mapping (T11533 ROOT CAUSE 3 fix)
-*
-* The legacy `signaldock.db` contains a `skills` table (36 rows — pre-seeded skill
-* slug catalog). In the consolidated global schema this becomes
-* `agent_registry_skills`. Without this entry the legacy `skills` table fell
-* through to an identity mapping, looked for a `skills` table in the global
-* cleo.db (absent), and was silently skipped — resulting in
-* agent_registry_skills=0 despite 36 source rows.
-*
-* @task T11622 (signaldock_* → agent_registry_* target rename; folds T11578 AC2)
-*/
-var AGENT_REGISTRY_DB_MAP = new Map([
-	["users", "agent_registry_users"],
-	["organization", "agent_registry_organization"],
-	["agents", "agent_registry_agents"],
-	["claim_codes", "agent_registry_claim_codes"],
-	["agent_capabilities", "agent_registry_agent_capabilities"],
-	["agent_skills", "agent_registry_agent_skills"],
-	["agent_connections", "agent_registry_agent_connections"],
-	["accounts", "agent_registry_accounts"],
-	["sessions", "agent_registry_sessions"],
-	["verifications", "agent_registry_verifications"],
-	["org_agent_keys", "agent_registry_org_agent_keys"],
-	["capabilities", "agent_registry_capabilities"],
-	["skills", "agent_registry_skills"]
-]);
-/**
-* skills.db (global) — tables from skills-schema.ts, all prefixed `skills_*`.
-*/
-var SKILLS_DB_MAP = new Map([
-	["skills", "skills_skills"],
-	["skill_usage", "skills_skill_usage"],
-	["skill_reviews", "skills_skill_reviews"],
-	["skill_patches", "skills_skill_patches"]
-]);
-/**
-* Infer the source DB kind from `LegacyDbDescriptor.name`.
-*
-* The descriptor names used in `buildSourceDescriptors()` are:
-*   `"tasks"`, `"brain (project)"`, `"conduit"`, `"nexus"`, `"signaldock"`, `"skills"`
-*/
-function inferSourceKind(sourceName) {
-	const n = sourceName.toLowerCase();
-	if (n.startsWith("tasks")) return "tasks";
-	if (n.startsWith("brain")) return "brain";
-	if (n.startsWith("conduit")) return "conduit";
-	if (n.startsWith("nexus")) return "nexus";
-	if (n.startsWith("signaldock")) return "signaldock";
-	if (n.startsWith("skills")) return "skills";
-	return null;
-}
-/**
-* Internal bookkeeping tables that exist in a legacy source DB but have NO
-* consolidated counterpart and carry no user data — they are recreated by the
-* runtime, not migrated. Matched by EXACT name.
-*
-* Each legacy per-domain SQLite file (`conduit.db`, `signaldock.db`,
-* `skills.db`, …) carries its OWN private schema-version / migration-ledger
-* table that records HOW that file was built — NOT user-payload data:
-*
-* - `_conduit_meta` / `_conduit_migrations` — conduit-sqlite's own
-*   schema-version + migration-ledger tables (see `conduit-sqlite.ts`).
-* - `_signaldock_meta` / `_signaldock_migrations` — agent-registry-store's own
-*   ledger tables (same class — T11577 global-scope cutover blocker).
-* - `_skills_meta` — skills.db's own schema-version row (same class — T11577).
-*
-* The consolidated `cleo.db` has its own Drizzle journal (`__drizzle_*`) for the
-* same purpose, so these legacy ledgers have no consolidated home. Row-comparing
-* them would count internal ledger rows as a user-data deficit and abort the
-* cutover. The {@link INTERNAL_LEDGER_PATTERN} below generalises the same skip
-* to ANY future `_<domain>_meta` / `_<domain>_migrations` ledger so a new source
-* DB never re-introduces this false-positive; these exact entries remain for
-* documentation + as a fast path.
-*
-* @task T11572 (parity gate over-abort — internal/meta exclusion)
-* @task T11577 (generalise to signaldock/skills + any per-source ledger)
-*/
-var INTERNAL_BOOKKEEPING_TABLES = new Set([
-	"_conduit_meta",
-	"_conduit_migrations",
-	"_signaldock_meta",
-	"_signaldock_migrations",
-	"_skills_meta"
-]);
-/**
-* Pattern matching a per-source SQLite **internal ledger** table: an underscore-
-* prefixed `_<domain>_meta` or `_<domain>_migrations` name where `<domain>` is a
-* lowercase identifier (e.g. `_conduit_meta`, `_signaldock_migrations`,
-* `_skills_meta`).
-*
-* Every legacy domain DB (conduit/signaldock/skills/…) materialises one of these
-* to track its own schema version / applied-migration history. They are private
-* bookkeeping — NOT migratable base data — and have no consolidated home (the
-* consolidated `cleo.db` keeps its own `__drizzle_*` journal). Generalising the
-* skip to this shape is future-proof: a NEW source DB that follows the same
-* `_<domain>_(meta|migrations)` convention is excluded automatically, so this
-* exact false-positive class can never abort the cutover again.
-*
-* The pattern is intentionally conservative — it requires the leading underscore
-* and the exact `_meta` / `_migrations` suffix so it can never match a real
-* data table (those are never underscore-prefixed in any legacy source schema).
-*
-* @task T11577 (parity gate over-abort — generalise per-source ledger skip)
-*/
-var INTERNAL_LEDGER_PATTERN = /^_[a-z][a-z0-9]*_(?:meta|migrations)$/;
-/**
-* FTS5 shadow-table suffixes. A full-text index `<base>_fts` (an `fts5` VIRTUAL
-* TABLE — e.g. `brain_decisions_fts`, `messages_fts`) materialises a family of
-* backing tables `<base>_fts_data`, `<base>_fts_idx`, `<base>_fts_docsize`,
-* `<base>_fts_config`, and (for `content=`-less indexes) `<base>_fts_content`.
-*
-* These are DERIVED from their content table and are REBUILT post-migration
-* (`brain-search.ts` issues `INSERT INTO <base>_fts(<base>_fts) VALUES('rebuild')`).
-* Their row counts do NOT correspond 1:1 to user rows, so comparing them against
-* an absent consolidated target produces a spurious N→0 deficit. They must be
-* excluded from the row-count-parity gate, not migrated.
-*
-* @task T11572 (parity gate over-abort — FTS5 shadow-table exclusion)
-*/
-var FTS5_SHADOW_SUFFIXES = [
-	"_fts_data",
-	"_fts_idx",
-	"_fts_docsize",
-	"_fts_config",
-	"_fts_content"
-];
-/**
-* Return `true` if `tableName` is a DERIVED or INTERNAL table that must be
-* EXCLUDED from the exodus row-count-parity gate (and from the copy path).
-*
-* This is the single, named, documented classification consumed by BOTH the
-* migrate copy loop and the `verifyMigration` parity check, so the two never
-* disagree about which tables carry migratable user data. It recognises:
-*
-*   1. **FTS5 virtual tables** — a bare `*_fts` name (e.g. `brain_decisions_fts`,
-*      `messages_fts`). The virtual table itself cannot be `INSERT … SELECT`-ed
-*      and is rebuilt from its content table after migration.
-*   2. **FTS5 shadow/backing tables** — `*_fts_data`, `*_fts_idx`,
-*      `*_fts_docsize`, `*_fts_config`, `*_fts_content` (see
-*      {@link FTS5_SHADOW_SUFFIXES}). Derived; rebuilt post-migration.
-*   3. **Internal bookkeeping** — any per-source schema-version / migration
-*      ledger: `_conduit_meta`, `_conduit_migrations`, `_signaldock_meta`,
-*      `_signaldock_migrations`, `_skills_meta`, and — generalised via
-*      {@link INTERNAL_LEDGER_PATTERN} — ANY `_<domain>_meta` /
-*      `_<domain>_migrations` ledger from a future source DB (see
-*      {@link INTERNAL_BOOKKEEPING_TABLES}). Schema-version ledgers with no
-*      consolidated home.
-*
-* A migration is "safe" iff every BASE-DATA row survives; these derived/internal
-* tables are NOT base data, so a 0-row consolidated counterpart for them is
-* expected and correct — not data loss.
-*
-* @param tableName - Physical table name from a legacy source DB.
-* @returns `true` when the table is derived/internal and must be skipped.
-*
-* @task T11572 (exodus parity gate: exclude FTS5 + internal/meta shadow tables)
-* @task T11577 (generalise internal-ledger skip to signaldock/skills + any per-source ledger)
-* @epic T11249 (E6)
-* @saga T11242
-*/
-function isDerivedOrInternalTable(tableName) {
-	if (INTERNAL_BOOKKEEPING_TABLES.has(tableName)) return true;
-	if (INTERNAL_LEDGER_PATTERN.test(tableName)) return true;
-	if (tableName.endsWith("_fts")) return true;
-	return FTS5_SHADOW_SUFFIXES.some((suffix) => tableName.endsWith(suffix));
-}
-/**
-* Resolve the consolidated target table name for a legacy source table.
-*
-* @param sourceName  - `LegacyDbDescriptor.name` (e.g. `"tasks"`, `"brain (project)"`).
-* @param legacyTable - Physical table name from the legacy source DB.
-* @returns A `TableNameResolution` describing how to copy (or skip) the table.
-*/
-function resolveConsolidatedTableName(sourceName, legacyTable) {
-	if (isDerivedOrInternalTable(legacyTable)) return {
-		kind: "skip",
-		reason: legacyTable.includes("_fts") ? `derived FTS5 table — rebuilt post-migration from its content table, not row-compared` : `internal bookkeeping table — no consolidated home (recreated by runtime)`
-	};
-	const kind = inferSourceKind(sourceName);
-	if (kind === null) return {
-		kind: "unknown",
-		targetName: legacyTable
-	};
-	let map;
-	switch (kind) {
-		case "tasks":
-			map = TASKS_DB_MAP;
-			break;
-		case "brain":
-			map = BRAIN_DB_MAP;
-			break;
-		case "conduit":
-			map = CONDUIT_DB_MAP;
-			break;
-		case "nexus":
-			map = NEXUS_DB_MAP;
-			break;
-		case "signaldock":
-			map = AGENT_REGISTRY_DB_MAP;
-			break;
-		case "skills":
-			map = SKILLS_DB_MAP;
-			break;
-	}
-	if (!map.has(legacyTable)) return {
-		kind: "mapped",
-		targetName: legacyTable
-	};
-	const consolidated = map.get(legacyTable);
-	if (consolidated === null || consolidated === void 0) return {
-		kind: "skip",
-		reason: getSkipReason(kind, legacyTable)
-	};
-	return {
-		kind: "mapped",
-		targetName: consolidated
-	};
-}
-/**
-* Return a human-readable explanation for why a table is intentionally excluded
-* from the consolidated schema.
-*/
-function getSkipReason(sourceKind, legacyTable) {
-	return {
-		brain_task_observations: "runtime-only observation cache (not Drizzle-managed); recreated lazily after exodus cutover",
-		brain_embeddings: "vec0 VIRTUAL TABLE — cannot be migrated via INSERT/SELECT; requires sqlite-vec extension; recreated lazily after exodus cutover",
-		brain_embeddings_info: "metadata companion to brain_embeddings vec0 virtual table; excluded from consolidated schema (derived/recreatable)"
-	}[legacyTable] ?? `table '${legacyTable}' from ${sourceKind} has no consolidated target`;
-}
-getLogger("exodus-count-parity");
-//#endregion
-//#region ../core/dist/store/exodus/plan.js
-/**
-* Exodus pre-flight plan builder.
-*
-* `buildExodusPlan()` computes the full migration plan — source DB paths,
-* combined size, free-disk availability, staging directory — BEFORE any
-* writes occur. A `--dry-run` caller can print the plan and exit early.
-*
-* ## Disk pre-flight (AC8 · right-sized T11838)
-*
-* The original gate required `availableBytes >= 3 * totalSourceBytes` — an
-* over-estimate that blocked large-fleet migrations even with ample headroom:
-* exodus never holds 3× the SUM of every source on disk at once. It copies one
-* source into staging at a time (lock released before the next) and writes a
-* single consolidated cleo.db whose size approximates the sum of source ROW data.
-*
-* The right-sized requirement is therefore
-* `STAGING_HEADROOM_FACTOR * largestSourceBytes + consolidatedEstimate`, where
-* `consolidatedEstimate ≈ totalSourceBytes` ({@link computeRequiredBytes}). The
-* check uses `statvfs` via `node:fs.statfsSync()` (Node 18+).
-*
-* @task T11248 (E5 · SG-DB-SUBSTRATE-V2)
-* @task T11838 (right-sized preflight + optional staging copy for large sources)
-* @saga T11242
-*/
-/**
-* Headroom multiplier applied to the LARGEST single source when sizing the
-* staging-copy footprint. The staging dir only ever holds ONE source backup at a
-* time (its advisory lock is released before the next source is touched), so the
-* peak staging footprint is the largest source plus a small slack for the
-* write-then-rename journal + SQLite sidecars — hence `1.2×`, not `3×` of the SUM.
-*
-* @task T11838
-*/
-var STAGING_HEADROOM_FACTOR = 1.2;
-/**
-* Per-source byte threshold above which the full staging `copyFileSync` backup
-* is skipped (the source is archived, not deleted, on success). Sized at 256 MiB
-* — comfortably above the small project DBs (tasks/conduit/skills/signaldock are
-* sub-MB to low-MB) but below the large global stores (a multi-GB `brain.db` or
-* `nexus.db`) whose redundant full-file copy is the costly case T11838 removes.
-*
-* @task T11838
-*/
-var STAGING_COPY_SKIP_THRESHOLD_BYTES = 256 * 1024 * 1024;
-/**
-* Compute the right-sized free-disk requirement for an exodus run (T11838).
-*
-* `STAGING_HEADROOM_FACTOR * largestSourceBytes` covers the peak staging-copy
-* footprint (one source at a time, plus slack), and `totalSourceBytes` is the
-* consolidated-cleo.db estimate (every source's row data lands there). The two
-* are additive because staging and the consolidated DB coexist on disk until the
-* sources are archived.
-*
-* @param totalSourceBytes   - Combined size of all source DB files in bytes.
-* @param largestSourceBytes - Size of the single largest source DB in bytes.
-* @returns The minimum free bytes the target filesystem must have.
-*/
-function computeRequiredBytes(totalSourceBytes, largestSourceBytes) {
-	return Math.ceil(STAGING_HEADROOM_FACTOR * largestSourceBytes) + totalSourceBytes;
-}
-/**
-* Build the ordered list of legacy source DB descriptors for a given project.
-*
-* Project-scoped sources live under `<project>/.cleo/`.
-* Global-scoped sources live under `getCleoHome()`.
-*/
-function buildSourceDescriptors(cwd) {
-	const cleoDir = resolveCleoDir(cwd);
-	const cleoHome = getCleoHome();
-	return [
-		{
-			name: "tasks",
-			path: join(cleoDir, "tasks.db"),
-			targetScope: "project"
-		},
-		{
-			name: "brain (project)",
-			path: join(cleoDir, "brain.db"),
-			targetScope: "project"
-		},
-		{
-			name: "conduit",
-			path: join(cleoDir, "conduit.db"),
-			targetScope: "project"
-		},
-		{
-			name: "nexus",
-			path: join(cleoHome, "nexus.db"),
-			targetScope: "global"
-		},
-		{
-			name: "signaldock",
-			path: join(cleoHome, "signaldock.db"),
-			targetScope: "global"
-		},
-		{
-			name: "skills",
-			path: join(cleoHome, "skills.db"),
-			targetScope: "global"
-		}
-	];
-}
-/**
-* Safely stat a file and return its size in bytes, or 0 if it does not exist.
-*/
-function safeFileBytes(filePath) {
-	try {
-		return statSync(filePath).size;
-	} catch {
-		return 0;
-	}
-}
-/**
-* Return available bytes on the filesystem that contains `dir`.
-*
-* Uses `statfsSync` (Node 18+). Falls back to 0 if unavailable.
-*/
-function getAvailableBytes(dir) {
-	try {
-		const result = statfsSync(dir);
-		return (result.bavail ?? result.bfree ?? 0) * (result.bsize ?? 4096);
-	} catch {
-		return 0;
-	}
-}
-/**
-* Derive the staging directory name from the current ISO-8601 timestamp.
-*
-* Pattern: `.cleo/exodus-staging-<YYYYMMDDTHHMMSSZ>`.
-* Colons are replaced with empty string (NTFS + shell-safe).
-*/
-function deriveStagingDirName() {
-	return `exodus-staging-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:]/g, "").replace(/\..+Z$/, "Z")}`;
-}
-/**
-* Scan for an existing staging directory from a previous (possibly crashed)
-* run inside the given `.cleo/` directory.
-*
-* Returns the absolute path to the most-recent staging dir, or `null` if none
-* exists.
-*/
-function findExistingStaging(cleoDir) {
-	try {
-		const stagingDirs = readdirSync(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => e.name).sort().reverse();
-		if (stagingDirs.length > 0) return join(cleoDir, stagingDirs[0]);
-	} catch {}
-	return null;
-}
-/**
-* Build the complete exodus plan.
-*
-* This is a pure read operation — no files are created or modified.
-* Pass the result to `runExodusMigrate()` to execute the migration.
-*
-* @param cwd - Working directory used to resolve the project root. Defaults to
-*   `process.cwd()`.
-* @returns {@link ExodusPlan} describing sources, disk availability, and paths.
-*
-* @task T11248 (AC8 — disk pre-flight)
-* @task T11838 (right-sized: largest-source factor + consolidated estimate)
-*/
-function buildExodusPlan(cwd) {
-	const cleoDir = resolveCleoDir(cwd);
-	const sources = buildSourceDescriptors(cwd);
-	const sourceBytes = sources.map((s) => safeFileBytes(s.path));
-	const totalSourceBytes = sourceBytes.reduce((sum, b) => sum + b, 0);
-	const largestSourceBytes = sourceBytes.reduce((max, b) => Math.max(max, b), 0);
-	const requiredBytes = computeRequiredBytes(totalSourceBytes, largestSourceBytes);
-	const availableBytes = getAvailableBytes(cleoDir);
-	const diskPreflight = totalSourceBytes === 0 || availableBytes >= requiredBytes;
-	const existingStaging = findExistingStaging(cleoDir);
-	return {
-		sources,
-		totalSourceBytes,
-		largestSourceBytes,
-		requiredBytes,
-		availableBytes,
-		diskPreflight,
-		stagingCopyThresholdBytes: STAGING_COPY_SKIP_THRESHOLD_BYTES,
-		stagingDir: existingStaging ?? join(cleoDir, deriveStagingDirName()),
-		resumeFromStaging: existingStaging !== null,
-		projectDbPath: resolveDualScopeDbPath("project", cwd),
-		globalDbPath: resolveDualScopeDbPath("global")
-	};
-}
-//#endregion
-//#region ../core/dist/store/exodus/column-transforms.js
-/**
-* Shared column-value transform layer for the exodus migration.
-*
-* The exodus copy (`migrate.ts`) does not move source values byte-for-byte into
-* the consolidated `cleo.db`: a handful of columns are TRANSFORMED on the way in
-* so they satisfy the consolidated schema's CHECK constraints (which the legacy
-* runtime DBs did not carry). Three transform classes exist:
-*
-*   1. **Epoch INTEGER → ISO-8601 TEXT** ({@link buildEpochToIsoExpr}) — for any
-*      target column carrying an ISO-GLOB CHECK ({@link detectIsoGlobColumns}).
-*      A per-row magnitude heuristic ({@link EPOCH_SECONDS_THRESHOLD}) classifies
-*      seconds vs milliseconds.
-*   2. **Legacy enum → canonical member** ({@link ENUM_NORMALIZATIONS} +
-*      {@link enumNormExpr}) — maps pre-tightening enum aliases (e.g.
-*      `tasks_commits.conventional_type` `'style'`/`'merge'` → `'chore'`).
-*   3. **Non-finite REAL → finite** ({@link NUMERIC_CLAMPS} +
-*      {@link numericClampExpr}) — `Inf`/`-Inf`/`NaN` → a finite in-range value
-*      (`brain_weight_history.delta_weight`).
-*
-* ## Why this module exists (T11809 · AC2)
-*
-* Before T11809 these transforms lived ONLY in `migrate.ts`. The parity verifier
-* (`verify-migration.ts`) digested RAW source values against the TRANSFORMED
-* target values, so every coerced column (epoch INTEGER vs ISO TEXT, legacy enum
-* vs canonical, Inf vs clamped) produced a `hashMatch === false` even on a
-* perfectly lossless migration — a false-negative that aborted the cutover and
-* lost the batch writes accumulated during the migrating open.
-*
-* Extracting the transform logic into ONE shared module lets the verifier digest
-* the SOURCE side **through the same transforms migrate applied**
-* ({@link buildDigestExpr}), so equal logical data digests equal. `migrate.ts`
-* re-imports these primitives so its copy behaviour stays byte-identical; the
-* verifier imports {@link buildDigestExpr} for the digest-oriented variant.
-*
-* @task T11809 (exodus verify applies source-side coercion — hashMatch on equal data)
-* @task T11546 (epoch→ISO coercion — original)
-* @task T11547 (enum normalization — original)
-* @task T11782 (non-finite numeric clamp — original)
-* @epic T11249 (E6)
-* @saga T11242
-*/
-/**
-* Determine a safe SQL literal default for a NOT NULL column with no schema
-* default, given its SQLite type affinity.
-*
-* Used by `migrate.ts` to coalesce NULL source values for target-only NOT NULL
-* columns so that rows are not silently dropped by `INSERT OR IGNORE` when a
-* source value is NULL (T11533 ROOT CAUSE 2 fix).
-*
-* @param colType - Raw `type` string from `PRAGMA table_info` (e.g. `"INTEGER"`,
-*   `"TEXT"`, `"REAL"`, `"BLOB"`, or compound forms like `"text NOT NULL"`).
-* @returns A SQL literal string suitable for embedding in a `COALESCE()` call.
-*/
-function typeDefaultLiteral(colType) {
-	const upper = colType.toUpperCase();
-	if (upper.includes("INT")) return "0";
-	if (upper.includes("REAL") || upper.includes("FLOAT") || upper.includes("DOUBLE")) return "0.0";
-	if (upper.includes("BLOB")) return "x''";
-	return "''";
-}
-/**
-* Per-(targetTable, column) normalization rules that map legacy enum values to
-* the canonical enum accepted by the consolidated schema CHECK constraints.
-*
-* Each entry is a function that, given the `srcRef` SQL expression for the
-* column, returns a SQL CASE expression that produces the canonical value.
-* Rows with already-canonical values pass through unchanged (the ELSE branch).
-*
-* ## Brain enum normalizations REMOVED (T11647)
-*
-* The brain memory family no longer participates in enum normalization. Its
-* consolidated exodus target now matches the LEGACY RUNTIME shape, which carries
-* NO SQL CHECK constraints (the `text({ enum })` unions are enforced at the
-* application layer only). With no CHECK to satisfy, coercing brain enum values
-* would be data corruption, not a fix — so every brain enum value is copied
-* VERBATIM. The historical brain rules (`brain_observations.{source_type,type}`,
-* `brain_decisions.{confirmation_state,decision_category,confidence,outcome,
-* decided_by}`) were deleted. The TASKS-domain rules below remain because those
-* consolidated tables keep their CHECK constraints.
-*
-* ## nexus/signaldock enum-drift audit (T11809 · AC1)
-*
-* A real-data audit of `nexus.db` (106 MB) and `signaldock.db` (280 KB) against
-* the consolidated CHECK enums found ZERO out-of-enum values for every
-* CHECK-constrained column that has source data: `nexus_nodes.kind` (24,482
-* rows), `nexus_relations.type` (39,163 rows), `nexus_contracts.type` (0 rows),
-* `nexus_sigils.role` (8 rows), `agent_registry_agents.status` (19 rows),
-* `agent_registry_users.role` (0 rows). No new normalization entry was required.
-* The reported "nexus/signaldock drop rows" symptom was in fact the AC2 verify
-* false-negative (epoch→ISO coercion makes the source digest differ from the
-* target digest), which fixing {@link buildDigestExpr} resolves — NOT a CHECK
-* drop. See the T11809 return notes for the full per-column row counts.
-*
-* Lookup key: `${targetTable}.${column}` (lowercase, dotted).
-*
-* @since T11547 (P0 data-loss fix)
-* @since T11548 (P0 final enum coverage)
-* @since T11647 (brain target = runtime shape — brain enum coercions removed)
-*/
-var ENUM_NORMALIZATIONS = new Map([
-	["tasks_task_commits.link_source", (src) => `CASE ${src} WHEN 'commit-message' THEN 'commit-subject' ELSE ${src} END`],
-	["tasks_architecture_decisions.status", (src) => `CASE WHEN lower(${src}) = 'accepted' OR lower(${src}) LIKE 'accepted %' OR lower(${src}) = 'approved' THEN 'accepted' WHEN lower(${src}) = 'proposed' THEN 'proposed' WHEN lower(${src}) = 'superseded' THEN 'superseded' WHEN lower(${src}) = 'deprecated' THEN 'deprecated' ELSE ${src} END`],
-	["tasks_commits.conventional_type", (src) => `CASE WHEN ${src} IS NULL THEN NULL WHEN ${src} IN ('feat', 'fix', 'chore', 'docs', 'refactor', 'test', 'build', 'ci', 'perf', 'revert', 'breaking') THEN ${src} ELSE 'chore' END`],
-	["tasks_task_relations.relation_type", (src) => `CASE ${src} WHEN 'grouped-by' THEN 'groups' ELSE ${src} END`],
-	["tasks_lifecycle_stages.stage_name", (src) => `CASE ${src} WHEN 'implemented' THEN 'implementation' WHEN 'qaPassed' THEN 'validation' WHEN 'testsPassed' THEN 'testing' ELSE ${src} END`],
-	["tasks_architecture_decisions.gate_status", (src) => `CASE WHEN ${src} LIKE 'passed%' THEN 'passed' WHEN ${src} = 'approved' THEN 'passed' ELSE ${src} END`],
-	["tasks_evidence_ac_bindings.binding_type", (src) => `CASE WHEN ${src} LIKE 'validator:%' THEN 'direct' ELSE ${src} END`]
-]);
-/**
-* Return a SQL CASE expression that normalises legacy enum values for `col` in
-* `targetTableName` to the canonical values accepted by the consolidated CHECK,
-* or return `null` when no normalization rule exists for this (table, column).
-*
-* @param targetTableName - Physical consolidated target table name.
-* @param col             - Column name.
-* @param srcRef          - SQL expression referencing the source column.
-* @returns A SQL CASE expression string, or `null` if no rule applies.
-*/
-function enumNormExpr(targetTableName, col, srcRef) {
-	const key = `${targetTableName}.${col}`;
-	const fn = ENUM_NORMALIZATIONS.get(key);
-	return fn ? fn(srcRef) : null;
-}
-/**
-* Per-(targetTable, column) numeric-clamp rules that coerce non-finite legacy
-* REAL values (`Inf` / `-Inf` / `NaN`) to a finite in-range value so the row is
-* NOT silently dropped by `INSERT OR IGNORE`.
-*
-* ## Why this exists (T11782)
-*
-* 188,926 of 697,780 legacy `brain_weight_history` rows carry
-* `delta_weight = Inf`/`-Inf` (the R-STDP plasticity writer saturated the delta
-* before the value was clamped at write time). SQLite stores ±Inf as the IEEE-754
-* float, but the consolidated `brain_weight_history.delta_weight` column is a
-* plain `real NOT NULL` with NO CHECK — so a verbatim copy would land the Inf
-* value. The historical deficit, however, was that those rows tripped a constraint
-* elsewhere in the copy chain and `INSERT OR IGNORE` dropped them, yielding a
-* deficit that fired the parity-gate abort. Clamping the non-finite value to a
-* finite member of the column's domain guarantees every row lands.
-*
-* The clamp mirrors the {@link ENUM_NORMALIZATIONS} shape: each entry is a
-* function `(srcRef) => CASE …`. Finite values pass through unchanged via the
-* ELSE branch. The `col != col` self-comparison is the canonical SQL NaN guard
-* (NaN is the only value not equal to itself); `9e999` is the SQLite literal that
-* evaluates to `+Infinity` (and `-9e999` to `-Infinity`).
-*
-* Lookup key: `${targetTable}.${column}` (lowercase, dotted).
-*
-* @since T11782 (P0 — brain_weight_history Inf recovery)
-*/
-var NUMERIC_CLAMPS = new Map([["brain_weight_history.delta_weight", (src) => `CASE WHEN ${src} = 9e999 THEN 1.0 WHEN ${src} = -9e999 THEN -1.0 WHEN ${src} != ${src} THEN 0.0 ELSE ${src} END`]]);
-/**
-* Return a SQL CASE expression that clamps non-finite legacy REAL values for
-* `col` in `targetTableName` to a finite in-range value, or `null` when no
-* clamp rule exists for this (table, column).
-*
-* @param targetTableName - Physical consolidated target table name.
-* @param col             - Column name.
-* @param srcRef          - SQL expression referencing the source column.
-* @returns A SQL CASE expression string, or `null` if no rule applies.
-*/
-function numericClampExpr(targetTableName, col, srcRef) {
-	const key = `${targetTableName}.${col}`;
-	const fn = NUMERIC_CLAMPS.get(key);
-	return fn ? fn(srcRef) : null;
-}
-/**
-* Regex to detect ISO GLOB CHECK constraints in DDL SQL.
-* Matches: `CHECK ("colname" IS NULL OR "colname" GLOB '[0-9]...')`
-* Uses `\[0-9` to match the literal `[0-9` at the start of the GLOB pattern.
-*/
-var ISO_CHECK_REGEX = /CHECK\s*\(\s*"([^"]+)"\s+IS\s+NULL\s+OR\s+"[^"]+"\s+GLOB\s+'\[0-9/gi;
-/**
-* Magnitude threshold distinguishing epoch SECONDS from epoch MILLISECONDS.
-*
-* A Unix epoch value for years 2020–2100 is roughly 1.6e9 – 4.1e9 seconds,
-* or 1.6e12 – 4.1e12 milliseconds. The safe boundary is 1e11 (100 billion):
-* any value BELOW 1e11 is in seconds (even year 2100 seconds ≈ 4.1e9 < 1e11);
-* any value AT OR ABOVE 1e11 is in milliseconds (year 2020 ms ≈ 1.6e12 > 1e11).
-*
-* This constant is embedded directly in the generated SQL CASE expression so
-* it is evaluated per-row — each row's epoch is classified independently.
-*/
-var EPOCH_SECONDS_THRESHOLD = 1e11;
-/**
-* Build a SQL expression that converts an INTEGER epoch column to ISO-8601 TEXT,
-* automatically detecting whether the stored value is in seconds or milliseconds
-* using a magnitude heuristic (T11549 correctness fix).
-*
-* ## Heuristic
-*
-* A per-row CASE checks whether the column value is below {@link EPOCH_SECONDS_THRESHOLD}
-* (100 billion). If so, the value is treated as seconds and passed directly to
-* `strftime(..., 'unixepoch')`. If at or above the threshold, it is divided by
-* 1000.0 first (milliseconds → seconds).
-*
-* This replaces the previous per-source heuristic which failed when individual
-* columns within a source DB used a different epoch unit than the majority of that
-* source's columns. The specific bug: `nexus.user_profile.{first_observed_at,
-* last_reinforced_at}` stores SECONDS (value ≈ 1.78e9) but the nexus source was
-* labeled `milliseconds`, causing these values to be divided by 1000 and converted
-* to a 1970 date.
-*
-* ## NULL handling
-*
-* A NULL source value is preserved as NULL so it passes the `IS NULL` branch of
-* the ISO GLOB CHECK constraint on the target column.
-*
-* @param srcRef - SQL expression referencing the source column value.
-* @returns A SQL CASE expression producing an ISO-8601 TEXT timestamp.
-*/
-function buildEpochToIsoExpr(srcRef) {
-	return `CASE WHEN ${srcRef} IS NULL THEN NULL WHEN ${srcRef} < ${EPOCH_SECONDS_THRESHOLD} THEN strftime('%Y-%m-%dT%H:%M:%fZ', ${srcRef}, 'unixepoch') ELSE strftime('%Y-%m-%dT%H:%M:%fZ', ${srcRef}/1000.0, 'unixepoch') END`;
-}
-/**
-* Parse the DDL for a given table from `sqlite_master` and return the set of
-* column names that have an ISO GLOB CHECK constraint.
-*
-* Reads the raw DDL text and uses a regex to extract column names appearing in
-* `CHECK ("colname" IS NULL OR "colname" GLOB '[0-9]...')` patterns. This is
-* robust to Drizzle's generated CHECK format (all CHECK constraints generated
-* by T11363 follow this exact pattern).
-*
-* @param db           - Target DB with the consolidated schema.
-* @param tableName    - Physical table name (consolidated, e.g. `conduit_messages`).
-* @param targetSchema - Schema name the target table lives in (`'main'`, or an
-*   ATTACH alias for cross-scope routing — ADR-090 nexus graph residency, T11539).
-* @returns Set of column names that require ISO GLOB validation.
-*/
-function detectIsoGlobColumns(db, tableName, targetSchema = "main") {
-	const escapedTable = tableName.replace(/'/g, "''");
-	const row = db.prepare(`SELECT sql FROM "${targetSchema}".sqlite_master WHERE type='table' AND name='${escapedTable}'`).get();
-	if (!row?.sql) return /* @__PURE__ */ new Set();
-	const isoColumns = /* @__PURE__ */ new Set();
-	ISO_CHECK_REGEX.lastIndex = 0;
-	for (const match of row.sql.matchAll(ISO_CHECK_REGEX)) isoColumns.add(match[1]);
-	return isoColumns;
-}
-/**
-* Return `true` when the source column's type affinity is INTEGER-like, so an
-* epoch→ISO coercion applies when the matching target column carries an ISO GLOB
-* CHECK. Empty affinity and `NUMERIC` are treated as integer-like (matching the
-* historical `buildSelectExpr` behaviour — legacy epoch columns sometimes carry
-* no declared type or a `NUMERIC` affinity).
-*
-* @param srcType - Raw `type` string from the source `PRAGMA table_info`.
-* @returns `true` if the source column should be considered an INTEGER epoch.
-*/
-function isIntegerSourceType(srcType) {
-	const upper = srcType.toUpperCase();
-	return upper.includes("INT") || upper === "" || upper === "NUMERIC";
-}
-/**
-* Wrap a digest value expression in the SAME `COALESCE(expr, type_default)`
-* substitution migrate's `buildSelectExpr` applies, when (and only when) the
-* matching TARGET column is NOT NULL without a schema default (T11836).
-*
-* On a faithful FRESH migration a NULL source value in such a column is stored
-* as the type default (`''`/`0`/`0.0`/`x''`) by migrate; digesting the source
-* raw would read NULL and diverge from the stored default — a false
-* `hashMatch === false` at equal row counts. Mirroring the COALESCE here makes
-* the source digest reflect what migrate actually stored, so the substitution is
-* a NON-FATAL diagnostic class rather than a content-corruption failure.
-*
-* @param expr   - The value expression produced by an upstream transform branch.
-* @param tgtCol - Target column metadata, or `undefined` when unavailable (no
-*   COALESCE applied — best-effort, biased to surfacing a real difference).
-* @returns The expression, COALESCE-wrapped when the target is NOT-NULL-without-default.
-*/
-function maybeCoalesceNotNull(expr, tgtCol) {
-	if (tgtCol === void 0) return expr;
-	if (!(tgtCol.notnull === 1 && tgtCol.dflt_value === null)) return expr;
-	return `COALESCE(${expr}, ${typeDefaultLiteral(tgtCol.type)})`;
-}
-/**
-* Build the SQL expression a column's SOURCE value must pass through so it
-* matches the canonical value the migration STORES in the target — for use by
-* the parity verifier's content digest (T11809 · AC2).
-*
-* This is the digest-oriented sibling of migrate's `buildSelectExpr`. It applies
-* the SAME value transforms the migration actually performs — and ONLY those:
-*
-*   1. **Epoch→ISO-8601** ({@link buildEpochToIsoExpr}) — when the target has an
-*      ISO GLOB CHECK and the source column is INTEGER-typed.
-*   2. **Non-finite numeric clamp** ({@link numericClampExpr}).
-*   3. **Enum-value normalization** ({@link enumNormExpr}).
-*   4. **Plain column reference** otherwise.
-*
-* ## NOT-NULL default substitution mirroring (T11836)
-*
-* After the value transform, the result is wrapped in the SAME
-* `COALESCE(expr, type_default)` substitution migrate's `buildSelectExpr` uses
-* for a TARGET column that is NOT NULL without a schema default (see
-* {@link maybeCoalesceNotNull}). migrate stores the type default (`''`/`0`/
-* `0.0`/`x''`) for a NULL source value in such a column; without mirroring it
-* here the source digest would read NULL and diverge from the stored default — a
-* false `hashMatch === false` on a faithful FRESH migration (the exact T11836
-* symptom). Mirroring it makes a NULL→NOT-NULL-default substitution a NON-FATAL
-* diagnostic class rather than a hash failure. The target metadata is supplied
-* via the `tgtColByCol` map; when it is absent (best-effort) no COALESCE is
-* applied and a genuine NULL→'' divergence remains visible as before.
-*
-* The returned expression is a bare SQL value expression (no `AS "col"` alias)
-* suitable for embedding directly in a `SELECT <expr> ... ORDER BY ...` digest
-* query. When no transform applies, a plain quoted column reference is returned.
-*
-* @param targetTableName - Physical consolidated target table name (transform
-*   lookup key).
-* @param col             - Column name (present in BOTH source and target).
-* @param srcType         - Raw `type` string from the source `PRAGMA table_info`.
-* @param isoGlobCols     - Set of target columns carrying an ISO GLOB CHECK.
-* @param tgtCol          - Target column metadata (NOT-NULL flag + default +
-*   affinity) for `col`, or `undefined` when unavailable.
-* @returns A SQL value expression that maps the raw source value to the canonical
-*   value the target stores.
-*/
-function buildDigestExpr(targetTableName, col, srcType, isoGlobCols, tgtCol) {
-	const srcRef = `"${col}"`;
-	if (isoGlobCols.has(col) && isIntegerSourceType(srcType)) return maybeCoalesceNotNull(buildEpochToIsoExpr(srcRef), tgtCol);
-	const clampExpr = numericClampExpr(targetTableName, col, srcRef);
-	if (clampExpr !== null) return maybeCoalesceNotNull(clampExpr, tgtCol);
-	const normExpr = enumNormExpr(targetTableName, col, srcRef);
-	if (normExpr !== null) return maybeCoalesceNotNull(normExpr, tgtCol);
-	return maybeCoalesceNotNull(srcRef, tgtCol);
-}
-//#endregion
-//#region ../core/dist/store/exodus/types.js
-/**
-* Shared types for the `cleo exodus` migration subsystem.
-*
-* The exodus subsystem migrates data from the legacy multi-DB fleet
-* (tasks.db · brain.db · conduit.db · nexus.db · signaldock.db · skills.db)
-* into the consolidated dual-scope `cleo.db` (project + global).
-*
-* @task T11248 (E5 · SG-DB-SUBSTRATE-V2)
-* @saga T11242
-* @adr ADR-068, ADR-069
-*/
-/**
-* Canonical schema version tag embedded in the exodus journal.
-*
-* This constant represents the Drizzle v1.0.0-rc.3 target schema "epoch"
-* for the dual-scope consolidation (T11245 · E2 · SG-DB-SUBSTRATE-V2).
-* The exact value is a stable marker — not a live hash — so that import
-* refuses cross-version migration unless `--force-cross-version` is passed.
-*/
-var EXODUS_TARGET_SCHEMA_VERSION = "drizzle-v1.0.0-rc.3/dual-scope/2026-05";
-//#endregion
-//#region ../core/dist/store/exodus/migrate.js
-/**
-* Exodus migration engine.
-*
-* `runExodusMigrate()` performs the actual data migration from legacy DBs
-* to the consolidated dual-scope `cleo.db`. Key invariants:
-*
-* - Source DBs are opened **read-only** via `openCleoDbSnapshot` (AC4).
-* - Source files are backed up to the staging dir before any writes (AC5).
-* - Import is wrapped in `BEGIN … COMMIT` per source; partial failure leaves
-*   the target DB untouched (AC6).
-* - Idempotency keys are propagated where the source row has them; generated
-*   where it does not (AC7).
-* - The staging journal is written atomically before each table copy so a
-*   crash can be resumed (AC5).
-*
-* ## Type coercion — epoch INTEGER → ISO-8601 TEXT (ROOT CAUSE 1 fix — T11546)
-*
-* Many legacy tables store timestamps as INTEGER epoch values (seconds or
-* milliseconds). The consolidated schema declares these columns as `text` with
-* a CHECK constraint: `CHECK ("col" IS NULL OR "col" GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*')`.
-*
-* When a source INTEGER value is inserted into a target TEXT+GLOB column, SQLite
-* coerces the integer to its decimal string representation (e.g. `"1717200000"`),
-* which fails the GLOB check. `INSERT OR IGNORE` then SILENTLY DROPS the entire
-* row. Result: all conduit_messages, brain_observations, etc. → 0 rows copied
-* while migrate reports `success: true, rowsCopied: 0`.
-*
-* Fix (two parts):
-*   (a) Per-column value transform: `detectEpochToIsoColumns()` reads the target
-*       table DDL from `sqlite_master` to identify columns with an ISO GLOB
-*       CHECK constraint. For those columns, if the source type affinity is
-*       INTEGER, the SELECT expression applies `strftime('%Y-%m-%dT%H:%M:%fZ',
-*       col, 'unixepoch')` (seconds) or the `/1000.0` ms variant depending on
-*       the per-source/table heuristic.
-*   (b) No-swallow assertion: after the bulk INSERT OR IGNORE, the actual
-*       `changes` count is compared against the source row count. Any shortfall
-*       is surfaced as a hard table-level error (not a silent success).
-*       PK/UNIQUE conflicts on resume are tolerated (they are expected and safe
-*       to ignore); unexpected shortfalls are flagged with a detailed error.
-*
-* ## ATTACH-once-per-source design (P0 fix — T11531)
-*
-* Each legacy source DB is ATTACHed to the target handle ONCE using a unique
-* per-source alias, all tables from that source are copied under the single
-* attachment, and then the alias is DETACHed. The ATTACH and DETACH are
-* performed **outside** the BEGIN/COMMIT transaction block because SQLite
-* forbids DETACH inside an active multi-statement transaction. The INSERT
-* statements themselves are issued inside the transaction for atomicity (AC6).
-*
-* Prior implementation called ATTACH/DETACH per-table inside an open
-* transaction — DETACH silently failed (SQLite restriction), the alias stayed
-* attached, and every subsequent table for the same source threw
-* "database _exodus_src_ is already in use", causing ~80 % data loss.
-*
-* ## FK-defer bulk copy (ROOT CAUSE 1 fix — T11533)
-*
-* Legacy tasks.db has self-referential FKs (`tasks.parent_id → tasks.id`),
-* cross-table FKs, and ~18 tables with FK relationships. When FK enforcement
-* is ON and tables are copied in arbitrary order (children before parents),
-* each child INSERT fails with FOREIGN KEY constraint error (SQLite errcode 787)
-* and the table is silently skipped — causing ~114K rows of data loss.
-*
-* Fix: set `PRAGMA foreign_keys = OFF` on the target connection before any
-* bulk INSERT, then after all tables are committed run `PRAGMA foreign_key_check`
-* to validate referential integrity. Genuine orphan rows surface as verify
-* failures; child-before-parent ordering artifacts are NOT dropped.
-* `PRAGMA foreign_keys = ON` is restored after the check.
-*
-* ## Name-mapping (ROOT CAUSE 1 fix — T11532)
-*
-* Legacy source DBs use UNPREFIXED table names (`tasks`, `messages`, `skills`,
-* …) while the consolidated `cleo.db` uses DOMAIN-PREFIXED names
-* (`tasks_tasks`, `conduit_messages`, `skills_skills`, …). The
-* `resolveConsolidatedTableName()` function from `table-name-map.ts` performs
-* the deterministic legacy→consolidated mapping before every copy. Tables with
-* no consolidated home emit an explicit WARN journal entry rather than being
-* silently discarded.
-*
-* ## Column-drift tolerance (ROOT CAUSE 2 fix — T11532, hardened T11533)
-*
-* When the source and target schemas differ (consolidated schema added/changed
-* columns vs legacy), the copy uses the INTERSECTION of source and target
-* column names. New target-only columns take their schema defaults; old
-* source-only columns are dropped. This is implemented by introspecting both
-* schemas via `PRAGMA table_info` and building an explicit column list.
-*
-* **NOT NULL / no-default hazard (T11533)**: target-only NOT NULL columns
-* WITHOUT a schema default caused `INSERT OR IGNORE` to silently drop rows
-* whose source value was NULL for that column (constraint violation → IGNORE).
-* The fix: for each intersection column that is NOT NULL in the target AND
-* has no `dflt_value`, the SELECT clause wraps the source reference in
-* `COALESCE(src_col, type_default)` so no row is silently dropped.
-* A type_default of `''` is used for TEXT affinity and `0` for numeric.
-*
-* ## Advisory file lock (AC4)
-*
-* The source DB files are opened read-only via `openCleoDbSnapshot` which
-* calls `new DatabaseSync(path, { readOnly: true })`. Node's SQLite binding
-* opens with `SQLITE_OPEN_READONLY`, which prevents any writes from this
-* process. We additionally write a `.lock` sentinel file next to each source
-* DB for the duration of the migration so that other CLEO processes can detect
-* an in-progress exodus and refuse to write.
-*
-* @task T11248 (E5 · SG-DB-SUBSTRATE-V2)
-* @task T11531 (P0 attach-leak fix)
-* @task T11532 (P0 name-mapping + column-drift + verify-rowid fix)
-* @task T11533 (P0 FK-defer + NOT NULL coalesce + signaldock-global map + nexus hash fix)
-* @task T11547 (P0 enum normalization — 7,421 rows recovered)
-* @task T11548 (P0 final enum coverage — 285 remaining rows zero-loss)
-* @task T11549 (P0 zero-loss final mile — brain_decisions enums + seconds-epoch coercion +
-*               agent_credentials/brain_release_links tables)
-* @saga T11242
-*/
-var log$2 = getLogger("exodus-migrate");
-var LOCK_SENTINEL_SUFFIX = ".exodus-lock";
-var JOURNAL_FILENAME = "exodus-journal.json";
-/**
-* Get the SQLite version string from an open DatabaseSync handle.
-*/
-function getSqliteVersion(db) {
-	try {
-		return db.prepare("SELECT sqlite_version() AS v").get()?.v ?? "unknown";
-	} catch {
-		return "unknown";
-	}
-}
-/**
-* Read the tables list from a legacy SQLite DB (excluding SQLite internals).
-*/
-function listTables$1(db) {
-	return db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%' ORDER BY name").all().map((r) => r.name);
-}
-/**
-* Write the journal file atomically (write-then-rename pattern).
-*/
-function writeJournal(stagingDir, journal) {
-	const journalPath = join(stagingDir, JOURNAL_FILENAME);
-	const tmpPath = `${journalPath}.tmp`;
-	writeFileSync(tmpPath, JSON.stringify(journal, null, 2) + "\n", "utf8");
-	renameSync(tmpPath, journalPath);
-}
-/**
-* Read an existing journal from the staging dir, or return `null`.
-*/
-function readJournal(stagingDir) {
-	const journalPath = join(stagingDir, JOURNAL_FILENAME);
-	if (!existsSync(journalPath)) return null;
-	try {
-		return JSON.parse(readFileSync(journalPath, "utf8"));
-	} catch {
-		return null;
-	}
-}
-/**
-* Invalidate the migrate journal after an aborted/rolled-back migration so a
-* post-abort retry RE-COPIES every table from scratch (T11572).
-*
-* ## Why this is required for retry correctness
-*
-* `runExodusMigrate` is resumable (AC5): after each table copy it writes a
-* journal entry with `status: 'done'`, and a subsequent run SKIPS any table
-* already marked `done`. That resume optimisation is correct only while the
-* consolidated rows it copied still EXIST. When the parity gate aborts, the
-* exodus-on-open hook truncates the consolidated tables back to EMPTY
-* (`rollbackConsolidatedToEmpty`) — but the on-disk journal still says every
-* table is `done`. The next open therefore re-triggers (consolidated empty),
-* runs `runExodusMigrate` again, finds every table `done` in the journal, copies
-* NOTHING, re-verifies the still-empty target, and re-aborts — a permanent loop
-* that pays the full migrate+verify cost on every open.
-*
-* Deleting the journal file forces `runExodusMigrate` to `initJournal()` afresh,
-* so the retry actually re-copies. Idempotent and best-effort: a missing journal
-* (or a missing staging dir) is a no-op. The staging backups are intentionally
-* LEFT in place (they are the legacy source-of-truth snapshots — harmless to
-* keep, valuable for forensics); only the progress journal is cleared.
-*
-* @param stagingDir - The staging directory whose `exodus-journal.json` to clear.
-* @returns `true` if a journal file was removed, `false` if there was nothing to
-*   remove.
-*
-* @task T11572 (abort/rollback must invalidate journal so retry re-copies)
-* @epic T11249 (E6)
-* @saga T11242
-*/
-function clearExodusJournal(stagingDir) {
-	const journalPath = join(stagingDir, JOURNAL_FILENAME);
-	try {
-		if (!existsSync(journalPath)) return false;
-		unlinkSync(journalPath);
-		log$2.info({ stagingDir }, "exodus: cleared migrate journal after abort/rollback — a retry will RE-COPY all tables");
-		return true;
-	} catch (err) {
-		log$2.warn({
-			err,
-			stagingDir
-		}, "exodus: failed to clear migrate journal after rollback (a retry may skip already-\"done\" tables)");
-		return false;
-	}
-}
-/**
-* Initialise a fresh journal object.
-*/
-function initJournal(sqliteVersion) {
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	return {
-		version: 1,
-		cleoVersion: getCleoVersion(),
-		targetSchemaVersion: EXODUS_TARGET_SCHEMA_VERSION,
-		nodeVersion: process.version,
-		sqliteVersion,
-		startedAt: now,
-		updatedAt: now,
-		tables: []
-	};
-}
-function lockPath(dbPath) {
-	return `${dbPath}${LOCK_SENTINEL_SUFFIX}`;
-}
-function acquireAdvisoryLock(dbPath) {
-	writeFileSync(lockPath(dbPath), JSON.stringify({
-		pid: process.pid,
-		ts: (/* @__PURE__ */ new Date()).toISOString()
-	}), "utf8");
-}
-function releaseAdvisoryLock(dbPath) {
-	try {
-		unlinkSync(lockPath(dbPath));
-	} catch {}
-}
-/**
-* Return a file's size in bytes, or `0` when it cannot be stat'd (T11838).
-*
-* Used to decide whether a source exceeds the staging-copy skip threshold. A
-* non-existent / unreadable source is treated as 0 bytes (it is filtered out of
-* the copy loop separately), so it never trips the large-source skip branch.
-*
-* @param filePath - Absolute path to the file to stat.
-* @returns The file size in bytes, or `0` on any stat failure.
-*/
-function safeStatBytes(filePath) {
-	try {
-		return statSync(filePath).size;
-	} catch {
-		return 0;
-	}
-}
-/**
-* Convert a source DB name to a safe, unique SQLite ATTACH alias.
-*
-* SQLite identifiers may contain only word characters; we prefix with
-* `_src_` so they never collide with target table names.
-*
-* @param name  - Logical name from `LegacyDbDescriptor.name` (e.g. `"brain (project)"`).
-* @param index - Positional index used when names collide after sanitisation.
-* @returns A unique, identifier-safe alias string.
-*/
-function makeAttachAlias(name, index) {
-	return `_src_${name.replace(/[^a-z0-9]/gi, "_").replace(/_+/g, "_").slice(0, 20)}_${index}`;
-}
-/**
-* Per-source-DB epoch unit lookup — used as a primary hint for the SQL magnitude
-* heuristic (T11549 coercion fix). When the magnitude heuristic is ambiguous
-* (value in the overlap zone), the source-level hint wins.
-*
-* Verified from schema source comments (§8.1 resolution):
-* - conduit.db:   `Math.floor(Date.now() / 1000)` → SECONDS
-* - brain.db:     `Date.now()` / `unixepoch * 1000` → MILLISECONDS
-* - signaldock.db: `strftime('%s','now')` → SECONDS
-* - tasks.db:     `Date.now()` → MILLISECONDS (most writers)
-* - nexus.db:     mixed — most columns are MILLISECONDS but `user_profile`
-*                  `first_observed_at`/`last_reinforced_at` are SECONDS
-*                  (written by PSYCHE dialectic writer via `Math.floor(Date.now() / 1000)`).
-*                  The magnitude heuristic handles this automatically.
-* - skills.db:    `Date.now()` → MILLISECONDS
-*/
-var SOURCE_EPOCH_UNITS = new Map([
-	["conduit", "seconds"],
-	["brain", "milliseconds"],
-	["brain (project)", "milliseconds"],
-	["brain (global)", "milliseconds"],
-	["signaldock", "seconds"],
-	["tasks", "milliseconds"],
-	["nexus", "milliseconds"],
-	["skills", "milliseconds"]
-]);
-/**
-* Return the epoch unit used by a given source DB's INTEGER timestamp columns.
-* Defaults to `'seconds'` for unknown sources (safe default — ISO-8601 output
-* will be off by 1000x only for ms sources, which are already enumerated above).
-*
-* NOTE: This is the per-source hint. The actual SQL expression generated by
-* `buildEpochToIsoExpr` uses a magnitude-based heuristic at the row level so
-* individual columns that diverge from the source default are handled correctly
-* (T11549 bug fix — nexus `user_profile` stores seconds despite nexus being
-* labeled milliseconds at the source level).
-*/
-function epochUnitForSource(sourceName) {
-	const key = sourceName.toLowerCase();
-	for (const [pattern, unit] of SOURCE_EPOCH_UNITS) if (key === pattern || key.startsWith(pattern)) return unit;
-	return "seconds";
-}
-/**
-* Build a SQL SELECT expression for a shared column, applying (in priority order):
-*
-* 1. **Epoch→ISO-8601 coercion** (T11546): when the target has an ISO GLOB CHECK
-*    and the source column is INTEGER-typed.
-* 2. **Non-finite numeric clamp** (T11782): when `NUMERIC_CLAMPS` has an entry
-*    for `(targetTableName, col)`, mapping `Inf`/`-Inf`/`NaN` to a finite in-range
-*    value so the row is not silently dropped.
-* 3. **Enum-value normalization** (T11547): when `ENUM_NORMALIZATIONS` has an
-*    entry for `(targetTableName, col)`, producing a SQL CASE expression that
-*    maps legacy values to canonical enum members without losing semantics.
-* 4. **NOT NULL coalesce** (T11533): for non-epoch, non-normalized columns whose
-*    target is NOT NULL with no schema default.
-* 5. **Plain column reference** otherwise.
-*
-* The epoch→ISO conversion uses `buildEpochToIsoExpr` (from `column-transforms.ts`)
-* which detects the epoch scale (seconds vs milliseconds) per-row using a magnitude
-* heuristic: values below `EPOCH_SECONDS_THRESHOLD` (1e11) are treated as seconds;
-* values at or above are treated as milliseconds and divided by 1000.0 before conversion
-* (T11549 correctness fix — the previous per-source unit was incorrect for
-* individual columns that diverged from the source default, e.g.
-* `nexus.user_profile.first_observed_at` stores SECONDS even though most nexus
-* writers use milliseconds).
-*
-* A NULL source value is preserved as NULL (passes the `IS NULL` branch of the
-* GLOB CHECK, and is OK for nullable columns).
-*
-* @param attachAlias      - ATTACH alias for the source DB.
-* @param legacyTable      - Legacy table name in the source.
-* @param targetTableName  - Physical consolidated target table name (for enum lookup).
-* @param col              - Column name.
-* @param srcType          - Raw type string from source `PRAGMA table_info`.
-* @param tgtInfo          - Target column metadata from `PRAGMA table_info`.
-* @param isoGlobCols      - Set of columns requiring ISO GLOB in the target.
-* @returns SQL expression string suitable for use in a SELECT clause.
-*/
-function buildSelectExpr(attachAlias, legacyTable, targetTableName, col, srcType, tgtInfo, isoGlobCols) {
-	const srcRef = `"${attachAlias}"."${legacyTable}"."${col}"`;
-	const srcUpper = srcType.toUpperCase();
-	const isIntegerSource = srcUpper.includes("INT") || srcUpper === "" || srcUpper === "NUMERIC";
-	const isNotNullWithoutDefault = tgtInfo.notnull === 1 && tgtInfo.dflt_value === null;
-	if (isoGlobCols.has(col) && isIntegerSource) {
-		const isoExpr = buildEpochToIsoExpr(srcRef);
-		if (isNotNullWithoutDefault) return `COALESCE(${isoExpr}, '') AS "${col}"`;
-		return `${isoExpr} AS "${col}"`;
-	}
-	const clampExpr = numericClampExpr(targetTableName, col, srcRef);
-	if (clampExpr !== null) {
-		if (isNotNullWithoutDefault) return `COALESCE(${clampExpr}, ${typeDefaultLiteral(tgtInfo.type)}) AS "${col}"`;
-		return `${clampExpr} AS "${col}"`;
-	}
-	const normExpr = enumNormExpr(targetTableName, col, srcRef);
-	if (normExpr !== null) {
-		if (isNotNullWithoutDefault) return `COALESCE(${normExpr}, ${typeDefaultLiteral(tgtInfo.type)}) AS "${col}"`;
-		return `${normExpr} AS "${col}"`;
-	}
-	if (isNotNullWithoutDefault) return `COALESCE(${srcRef}, ${typeDefaultLiteral(tgtInfo.type)}) AS "${col}"`;
-	return srcRef;
-}
-/**
-* Copy all rows from a legacy source table (in the already-attached alias) into
-* the corresponding consolidated target table.
-*
-* ## What changed in T11532 vs the T11531 version:
-*
-* 1. **Name mapping (ROOT CAUSE 1 — T11532)**: `legacyTableName` is resolved to
-*    its consolidated name via `resolveConsolidatedTableName()`. Without this,
-*    `tasks` (legacy) was looked up as `main."tasks"` which doesn't exist in
-*    the consolidated schema (the real target is `tasks_tasks`).
-*
-* 2. **Column-drift tolerance (ROOT CAUSE 2 — T11532 + T11533)**: the INSERT
-*    uses the INTERSECTION of source and target column lists rather than source
-*    columns verbatim. When the consolidated schema added new columns, old code
-*    failed. Target-only NOT NULL columns without defaults now get COALESCE()
-*    wrapping in the SELECT so NULL source values don't cause silent row drops.
-*
-* 3. **Explicit skip (ROOT CAUSE 5)**: tables intentionally excluded from the
-*    consolidated schema (virtual tables, orphan telemetry, etc.) now return
-*    a logged skip result rather than being silently treated as "target not
-*    found".
-*
-* 4. **Epoch→ISO coercion (ROOT CAUSE 1 — T11546)**: columns with an ISO GLOB
-*    CHECK in the target that are INTEGER-typed in the source are converted via
-*    `strftime('%Y-%m-%dT%H:%M:%fZ', col[/1000.0], 'unixepoch')`. Without this,
-*    `INSERT OR IGNORE` silently drops ALL rows for those tables (CHECK fails
-*    for every row because an integer like `1717200000` doesn't match the GLOB).
-*
-* 5. **No-swallow assertion (ROOT CAUSE 1b — T11546)**: after the bulk INSERT,
-*    `changes` is compared against the source row count. A shortfall is a hard
-*    per-table error. PK/UNIQUE conflicts on idempotent resume are expected and
-*    tolerated (checked via count of existing rows); CHECK constraint drops are
-*    not tolerated.
-*
-* **Pre-condition**: the caller has already executed
-* `ATTACH DATABASE '<path>' AS "<attachAlias>"` on `targetNativeDb`, and
-* `PRAGMA foreign_keys = OFF` has been set so FK ordering doesn't matter.
-*
-* ## Cross-scope routing (ADR-090 · T11539)
-*
-* `targetSchema` defaults to `'main'` (the connection's own consolidated DB). For
-* the four nexus code-graph tables, which are extracted from the GLOBAL `nexus.db`
-* source but must land in the PROJECT consolidated `cleo.db`, the caller attaches
-* the project DB under an alias on the SAME connection and passes that alias as
-* `targetSchema`. All target-side introspection (`sqlite_master`, `PRAGMA
-* table_info`) and the `INSERT OR IGNORE` are then schema-qualified to that
-* attached DB instead of `main`.
-*
-* @param targetNativeDb   - Writable target handle (mid-transaction, FK OFF).
-* @param srcNativeDb      - Read-only source snapshot (for metadata queries).
-* @param attachAlias      - Alias under which the source is attached.
-* @param legacyTableName  - Physical table name in the legacy source DB.
-* @param sourceName       - `LegacyDbDescriptor.name` (for name resolution).
-* @param targetSchema     - Schema the consolidated target table lives in
-*   (`'main'` by default, or an ATTACH alias for cross-scope routing).
-*/
-function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyTableName, sourceName, targetSchema = "main") {
-	const resolution = resolveConsolidatedTableName(sourceName, legacyTableName);
-	if (resolution.kind === "skip") {
-		log$2.warn({
-			legacyTableName,
-			sourceName,
-			reason: resolution.reason
-		}, `Exodus: explicitly skipping table — ${resolution.reason}`);
-		return {
-			rowsCopied: 0,
-			skipped: true,
-			reason: resolution.reason
-		};
-	}
-	const targetTableName = resolution.targetName;
-	const srcPragma = srcNativeDb.prepare(`PRAGMA table_info("${legacyTableName}")`).all();
-	const srcColumns = new Set(srcPragma.map((r) => r.name));
-	if (srcColumns.size === 0) return {
-		rowsCopied: 0,
-		skipped: false
-	};
-	const sourceCount = srcNativeDb.prepare(`SELECT COUNT(*) AS c FROM "${legacyTableName}"`).get()?.c ?? 0;
-	if (sourceCount === 0) return {
-		rowsCopied: 0,
-		skipped: false
-	};
-	const escapedTarget = targetTableName.replace(/'/g, "''");
-	if (!targetNativeDb.prepare(`SELECT name FROM "${targetSchema}".sqlite_master WHERE type='table' AND name='${escapedTarget}'`).get()) {
-		const reason = `consolidated target '${targetTableName}' not found (mapped from legacy '${legacyTableName}')`;
-		log$2.warn({
-			legacyTableName,
-			targetTableName,
-			sourceName,
-			attachAlias,
-			targetSchema
-		}, `Exodus: ${reason}`);
-		return {
-			rowsCopied: 0,
-			skipped: true,
-			reason
-		};
-	}
-	const tgtPragma = targetNativeDb.prepare(`PRAGMA "${targetSchema}".table_info("${targetTableName}")`).all();
-	const tgtColMap = new Map(tgtPragma.map((r) => [r.name, r]));
-	const sharedColumns = srcPragma.map((r) => r.name).filter((col) => tgtColMap.has(col));
-	if (sharedColumns.length === 0) {
-		const reason = `no overlapping columns between source '${legacyTableName}' and target '${targetTableName}'`;
-		log$2.warn({
-			legacyTableName,
-			targetTableName,
-			sourceName
-		}, `Exodus: ${reason}`);
-		return {
-			rowsCopied: 0,
-			skipped: true,
-			reason
-		};
-	}
-	const srcOnlyColumns = srcPragma.map((r) => r.name).filter((c) => !tgtColMap.has(c));
-	const tgtOnlyColumns = tgtPragma.map((r) => r.name).filter((c) => !srcColumns.has(c));
-	if (srcOnlyColumns.length > 0 || tgtOnlyColumns.length > 0) log$2.info({
-		legacyTableName,
-		targetTableName,
-		sourceName,
-		srcOnlyColumns,
-		tgtOnlyColumns
-	}, "Exodus: column drift detected — copying intersection, dropping src-only cols, using defaults for tgt-only cols");
-	const isoGlobCols = detectIsoGlobColumns(targetNativeDb, targetTableName, targetSchema);
-	const epochUnitHint = epochUnitForSource(sourceName);
-	const srcTypeMap = new Map(srcPragma.map((r) => [r.name, r.type]));
-	if (isoGlobCols.size > 0) {
-		const coercedCols = sharedColumns.filter((col) => {
-			const upper = (srcTypeMap.get(col) ?? "").toUpperCase();
-			return isoGlobCols.has(col) && (upper.includes("INT") || upper === "" || upper === "NUMERIC");
-		});
-		if (coercedCols.length > 0) log$2.info({
-			legacyTableName,
-			targetTableName,
-			sourceName,
-			coercedCols,
-			epochUnitHint
-		}, `Exodus: applying epoch→ISO coercion (magnitude heuristic) for ${coercedCols.length} column(s) (T11546+T11549)`);
-	}
-	const normalizedCols = sharedColumns.filter((col) => ENUM_NORMALIZATIONS.has(`${targetTableName}.${col}`));
-	if (normalizedCols.length > 0) log$2.info({
-		legacyTableName,
-		targetTableName,
-		sourceName,
-		normalizedCols
-	}, `Exodus: applying enum-value normalization for ${normalizedCols.length} column(s) (T11547)`);
-	const clampedCols = sharedColumns.filter((col) => NUMERIC_CLAMPS.has(`${targetTableName}.${col}`));
-	if (clampedCols.length > 0) log$2.info({
-		legacyTableName,
-		targetTableName,
-		sourceName,
-		clampedCols
-	}, `Exodus: applying non-finite numeric clamp for ${clampedCols.length} column(s) (T11782)`);
-	const selectExprs = sharedColumns.map((col) => {
-		return buildSelectExpr(attachAlias, legacyTableName, targetTableName, col, srcTypeMap.get(col) ?? "", tgtColMap.get(col), isoGlobCols);
-	});
-	const tgtOnlyNotNullCols = tgtOnlyColumns.filter((col) => {
-		const info = tgtColMap.get(col);
-		return info !== void 0 && info.notnull === 1 && info.dflt_value === null;
-	});
-	const allInsertCols = [...sharedColumns, ...tgtOnlyNotNullCols];
-	const allSelectExprs = [...selectExprs, ...tgtOnlyNotNullCols.map((col) => {
-		return `${typeDefaultLiteral(tgtColMap.get(col).type)} AS "${col}"`;
-	})];
-	const colList = allInsertCols.map((c) => `"${c}"`).join(", ");
-	const selectList = allSelectExprs.join(", ");
-	const existingBeforeRow = targetNativeDb.prepare(`SELECT COUNT(*) AS c FROM "${targetSchema}"."${targetTableName}"`).get();
-	const existingBefore = Number(existingBeforeRow?.c ?? 0);
-	const rowsCopied = targetNativeDb.prepare(`INSERT OR IGNORE INTO "${targetSchema}"."${targetTableName}" (${colList}) SELECT ${selectList} FROM "${attachAlias}"."${legacyTableName}"`).run().changes ?? 0;
-	if (rowsCopied < sourceCount) {
-		const presentAccountedFor = existingBefore + rowsCopied;
-		if (presentAccountedFor >= sourceCount) {
-			log$2.info({
-				legacyTableName,
-				targetTableName,
-				sourceName,
-				sourceCount,
-				rowsCopied,
-				existingBefore
-			}, `Exodus: '${legacyTableName}'→'${targetTableName}' — ${sourceCount - rowsCopied} of ${sourceCount} row(s) already present in target (idempotent PK dedup), ${rowsCopied} newly copied; no loss`);
-			return {
-				rowsCopied,
-				skipped: false
-			};
-		}
-		const missing = sourceCount - presentAccountedFor;
-		const reason = `INSERT OR IGNORE lost ${missing} of ${sourceCount} rows from '${legacyTableName}'→'${targetTableName}' (rowsCopied=${rowsCopied}, existingBefore=${existingBefore}) — a CHECK/NOT NULL/type/enum constraint rejected them (NOT PK dedup); inspect epoch coercion + enum normalization. verify will confirm.`;
-		log$2.error({
-			legacyTableName,
-			targetTableName,
-			sourceName,
-			sourceCount,
-			rowsCopied,
-			existingBefore,
-			missing
-		}, `Exodus: ${reason}`);
-		return {
-			rowsCopied,
-			skipped: false,
-			reason
-		};
-	}
-	return {
-		rowsCopied,
-		skipped: false
-	};
-}
-/**
-* Validate that the journal's schema version matches the current target version.
-*
-* When `forceCrossVersion === true`, mismatches are logged but not fatal.
-*/
-function checkSchemaVersion(journal, forceCrossVersion) {
-	if (journal.targetSchemaVersion !== "drizzle-v1.0.0-rc.3/dual-scope/2026-05") {
-		const msg = `Schema version mismatch: journal=${journal.targetSchemaVersion}, expected=${EXODUS_TARGET_SCHEMA_VERSION}`;
-		if (forceCrossVersion) {
-			log$2.warn(msg + " (--force-cross-version: continuing anyway)");
-			return true;
-		}
-		log$2.error(msg + " — pass --force-cross-version to override");
-		return false;
-	}
-	return true;
-}
-/**
-* Run the exodus migration.
-*
-* @param plan               - Pre-flight plan from `buildExodusPlan()`.
-* @param forceCrossVersion  - Skip the schema-version guard (AC9).
-* @param onProgress         - Optional progress callback called after each table.
-*
-* @returns {@link ExodusMigrateResult}
-*
-* @task T11248 (AC4, AC5, AC6, AC7, AC9)
-* @task T11531 (P0 attach-leak fix)
-*/
-async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
-	const { sources, stagingDir, diskPreflight, projectDbPath, globalDbPath } = plan;
-	if (!diskPreflight) {
-		const shortfall = Math.max(0, plan.requiredBytes - plan.availableBytes);
-		return {
-			ok: false,
-			tables: [],
-			stagingDir,
-			backupPaths: [],
-			error: `Insufficient disk space for exodus: need ≥${plan.requiredBytes} bytes (≈${STAGING_HEADROOM_FACTOR}× largest source ${plan.largestSourceBytes} + consolidated estimate ${plan.totalSourceBytes}), but only ${plan.availableBytes} bytes are free on the target filesystem — ${shortfall} bytes short. Free up at least ${shortfall} bytes (e.g. \`cleo backup prune\`, clear caches), or move the .cleo/ directory to a larger volume, then retry.`
-		};
-	}
-	mkdirSync(stagingDir, { recursive: true });
-	let sqliteVersion = "unknown";
-	for (const src of sources) if (existsSync(src.path)) {
-		const snap = openCleoDbSnapshot(src.path, { readOnly: true });
-		sqliteVersion = getSqliteVersion(snap.db);
-		snap.close();
-		break;
-	}
-	let journal = readJournal(stagingDir);
-	if (journal === null) journal = initJournal(sqliteVersion);
-	else {
-		if (!checkSchemaVersion(journal, forceCrossVersion)) return {
-			ok: false,
-			tables: [],
-			stagingDir,
-			backupPaths: [],
-			error: "Schema version mismatch. Pass --force-cross-version to override."
-		};
-		onProgress?.("Resuming from existing staging journal…");
-	}
-	const backupPaths = [];
-	const allTableResults = [];
-	const lockedPaths = [];
-	let projectHandle = null;
-	let globalHandle = null;
-	try {
-		for (const src of sources) {
-			if (!existsSync(src.path)) continue;
-			const backupDest = join(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
-			const srcBytes = safeStatBytes(src.path);
-			if (srcBytes > plan.stagingCopyThresholdBytes) onProgress?.(`Skipping full staging copy of ${src.name} (${srcBytes} bytes > ${plan.stagingCopyThresholdBytes} threshold) — source is archived, not deleted, on success.`);
-			else if (!existsSync(backupDest)) {
-				onProgress?.(`Backing up ${src.name} → staging dir…`);
-				copyFileSync(src.path, backupDest);
-				backupPaths.push(backupDest);
-			}
-			acquireAdvisoryLock(src.path);
-			lockedPaths.push(src.path);
-		}
-		onProgress?.("Opening DEDICATED project-scope cleo.db connection (running migrations)…");
-		projectHandle = await openDualScopeDbAtPath("project", projectDbPath, void 0, { dedicated: true });
-		onProgress?.("Opening DEDICATED global-scope cleo.db connection (running migrations)…");
-		globalHandle = await openDualScopeDbAtPath("global", globalDbPath, void 0, { dedicated: true });
-		function extractNativeDb(handle) {
-			const drizzleHandle = handle.db;
-			const client = drizzleHandle["$client"];
-			if (client && typeof client["prepare"] === "function") return client;
-			if (typeof drizzleHandle["prepare"] === "function") return drizzleHandle;
-			throw new Error("Could not extract native DatabaseSync from dual-scope DB handle");
-		}
-		const projectNative = extractNativeDb(projectHandle);
-		const globalNative = extractNativeDb(globalHandle);
-		const projectSources = sources.filter((s) => s.targetScope === "project" && existsSync(s.path));
-		const globalSources = sources.filter((s) => s.targetScope === "global" && existsSync(s.path));
-		await migrateScope("project", projectSources, projectNative, journal, stagingDir, allTableResults, onProgress);
-		await migrateScope("global", globalSources, globalNative, journal, stagingDir, allTableResults, onProgress, projectDbPath);
-		journal.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		writeJournal(stagingDir, journal);
-		return {
-			ok: true,
-			tables: allTableResults,
-			stagingDir,
-			backupPaths
-		};
-	} catch (err) {
-		const error = err instanceof Error ? err.message : String(err);
-		log$2.error({ err }, "Exodus migration failed");
-		return {
-			ok: false,
-			tables: allTableResults,
-			stagingDir,
-			backupPaths,
-			error
-		};
-	} finally {
-		try {
-			projectHandle?.close();
-		} catch {}
-		try {
-			globalHandle?.close();
-		} catch {}
-		for (const p of lockedPaths) releaseAdvisoryLock(p);
-	}
-}
-/**
-* Migrate all tables from the given sources into the target native DB.
-*
-* ## ATTACH-once-per-source protocol (T11531)
-*
-* SQLite forbids `DETACH` inside an active multi-statement transaction.
-* To avoid the "database alias is already in use" error that caused ~80 %
-* data loss, we use the following sequence **per source DB**:
-*
-*   1. ATTACH the source path under a unique alias (outside any transaction).
-*   2. Open a read-only snapshot of the source for metadata queries.
-*   3. BEGIN the write transaction on the target.
-*   4. INSERT OR IGNORE … SELECT for each table using the attached alias.
-*   5. COMMIT (or ROLLBACK on error).
-*   6. DETACH the source alias in `finally` (outside the committed transaction).
-*   7. Close the read-only snapshot.
-*
-* Each source gets its own unique alias (`_src_<name>_<index>`) so multiple
-* sources can be processed sequentially without alias conflicts.
-*
-* ## FK-defer protocol (T11533 ROOT CAUSE 1)
-*
-* Before the first INSERT in any scope, foreign-key enforcement is switched OFF
-* on the target connection (`PRAGMA foreign_keys = OFF`) so copy order does not
-* matter (avoids "FOREIGN KEY constraint failed" for child-before-parent copies).
-* After all sources in the scope are committed, `PRAGMA foreign_key_check` is
-* executed to surface genuinely orphaned rows, and then FK enforcement is
-* restored (`PRAGMA foreign_keys = ON`).
-*
-* Sequence across all sources in a scope:
-*   PRAGMA foreign_keys = OFF
-*   for each source:
-*     ATTACH … AS alias (outside tx)
-*     BEGIN
-*     INSERT … SELECT for each table
-*     COMMIT
-*     DETACH alias (outside tx)
-*   PRAGMA foreign_key_check  → log orphans as warnings
-*   PRAGMA foreign_keys = ON
-*/
-async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir, allTableResults, onProgress, crossScopeTargetPath) {
-	if (sources.length === 0) return;
-	onProgress?.(`Migrating ${scope}-scope sources…`);
-	targetNativeDb.exec("PRAGMA foreign_keys = OFF");
-	log$2.info({ scope }, "Exodus: foreign_keys=OFF for bulk copy (T11533 FK-defer)");
-	try {
-		for (let i = 0; i < sources.length; i++) {
-			const src = sources[i];
-			const attachAlias = makeAttachAlias(src.name, i);
-			const escapedPath = src.path.replace(/'/g, "''");
-			targetNativeDb.exec(`ATTACH DATABASE '${escapedPath}' AS "${attachAlias}"`);
-			onProgress?.(`  [${src.name}] Attached as "${attachAlias}"`);
-			let crossAlias = null;
-			if (crossScopeTargetPath) {
-				crossAlias = `_xscope_${attachAlias}`;
-				const escapedCrossPath = crossScopeTargetPath.replace(/'/g, "''");
-				targetNativeDb.exec(`ATTACH DATABASE '${escapedCrossPath}' AS "${crossAlias}"`);
-				onProgress?.(`  [${src.name}] Cross-scope target attached as "${crossAlias}"`);
-			}
-			const snap = openCleoDbSnapshot(src.path, { readOnly: true });
-			try {
-				const tables = listTables$1(snap.db);
-				targetNativeDb.exec("BEGIN");
-				let txOpen = true;
-				try {
-					for (const tableName of tables) {
-						const existing = journal.tables.find((e) => e.sourceDb === src.name && e.tableName === tableName);
-						if (existing?.status === "done") {
-							onProgress?.(`  ↳ ${src.name}.${tableName} — already done (resuming)`);
-							allTableResults.push({
-								sourceDb: src.name,
-								tableName,
-								rowsCopied: existing.rowsCopied,
-								skipped: false
-							});
-							continue;
-						}
-						onProgress?.(`  ↳ Copying ${src.name}.${tableName}…`);
-						let rowsCopied = 0;
-						let status = "done";
-						let errorMsg;
-						let skipped = false;
-						try {
-							const effectiveScope = resolveTableTargetScope(src.name, tableName, scope);
-							const targetSchema = effectiveScope !== scope && crossAlias ? crossAlias : "main";
-							if (effectiveScope !== scope && !crossAlias) throw new Error(`Table '${tableName}' from '${src.name}' routes to ${effectiveScope} scope but no cross-scope target was attached for the ${scope} pass (ADR-090 T11539)`);
-							const copyResult = copyTableFromAttached(targetNativeDb, snap.db, attachAlias, tableName, src.name, targetSchema);
-							rowsCopied = copyResult.rowsCopied;
-							if (copyResult.skipped) {
-								status = "skipped";
-								errorMsg = copyResult.reason;
-								skipped = true;
-							} else if (copyResult.reason) {
-								status = "partial";
-								errorMsg = copyResult.reason;
-							}
-						} catch (err) {
-							const msg = err instanceof Error ? err.message : String(err);
-							log$2.warn({
-								tableName,
-								sourceDb: src.name,
-								err
-							}, "Table copy failed — skipping");
-							status = "skipped";
-							errorMsg = msg;
-							skipped = true;
-						}
-						const entry = {
-							sourceDb: src.name,
-							tableName,
-							status,
-							rowsCopied,
-							updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-							...errorMsg ? { error: errorMsg } : {}
-						};
-						const idx = journal.tables.findIndex((e) => e.sourceDb === src.name && e.tableName === tableName);
-						if (idx >= 0) journal.tables[idx] = entry;
-						else journal.tables.push(entry);
-						journal.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-						writeJournal(stagingDir, journal);
-						allTableResults.push({
-							sourceDb: src.name,
-							tableName,
-							rowsCopied,
-							skipped,
-							reason: errorMsg
-						});
-					}
-					targetNativeDb.exec("COMMIT");
-					txOpen = false;
-				} catch (err) {
-					if (txOpen) try {
-						targetNativeDb.exec("ROLLBACK");
-					} catch {}
-					throw err;
-				}
-			} finally {
-				snap.close();
-				try {
-					targetNativeDb.exec(`DETACH DATABASE "${attachAlias}"`);
-					onProgress?.(`  [${src.name}] Detached "${attachAlias}"`);
-				} catch (detachErr) {
-					log$2.warn({
-						attachAlias,
-						sourceDb: src.name,
-						err: detachErr
-					}, "DETACH failed — alias will be released on DB close");
-				}
-				if (crossAlias) try {
-					targetNativeDb.exec(`DETACH DATABASE "${crossAlias}"`);
-					onProgress?.(`  [${src.name}] Cross-scope target detached "${crossAlias}"`);
-				} catch (detachErr) {
-					log$2.warn({
-						crossAlias,
-						sourceDb: src.name,
-						err: detachErr
-					}, "Cross-scope DETACH failed — alias will be released on DB close");
-				}
-			}
-		}
-	} finally {
-		try {
-			const orphans = targetNativeDb.prepare("PRAGMA foreign_key_check").all();
-			if (orphans.length > 0) log$2.warn({
-				scope,
-				orphanCount: orphans.length,
-				sample: orphans.slice(0, 5)
-			}, `Exodus: PRAGMA foreign_key_check found ${orphans.length} orphan row(s) after bulk copy — these are genuine data orphans (not ordering artifacts)`);
-			else log$2.info({ scope }, "Exodus: PRAGMA foreign_key_check PASSED — no orphan rows");
-		} catch (checkErr) {
-			log$2.warn({
-				scope,
-				err: checkErr
-			}, "Exodus: PRAGMA foreign_key_check failed (non-fatal) — target schema may not have FK constraints enabled");
-		}
-		try {
-			targetNativeDb.exec("PRAGMA foreign_keys = ON");
-			log$2.info({ scope }, "Exodus: foreign_keys=ON restored after bulk copy");
-		} catch (fkErr) {
-			log$2.warn({
-				scope,
-				err: fkErr
-			}, "Exodus: could not restore foreign_keys=ON (non-fatal)");
-		}
-	}
-}
-getLogger("exodus-seal");
-//#endregion
-//#region ../core/dist/store/exodus/verify-migration.js
-/**
-* Reusable CORE migration-parity primitive — `verifyMigration()`.
-*
-* This is the durable guard (T11551 · DHQ-045) that prevents the exodus
-* dual-DB consolidation from silently losing rows. It is intentionally generic:
-* given a set of legacy source DBs and the consolidated target DB paths, it
-* returns a typed {@link VerifyMigrationResult} covering FOUR failure classes:
-*
-*   1. **Per-table row-count parity** — every data-bearing source table's
-*      consolidated counterpart MUST NOT have FEWER rows than the source (a
-*      DEFICIT = data loss → failure). A SURPLUS (target > source — e.g.
-*      `nexus_audit_log` gaining the migration's own audit writes during the
-*      migrating open) is NOT loss and is tolerated with a WARN (T11577). The
-*      per-table `countMatch` field stays a strict `source === target`
-*      diagnostic; only a deficit contributes a failure.
-*   2. **`PRAGMA foreign_key_check`** — genuine referential orphans on the
-*      consolidated target surface as failures (not copy-order artifacts).
-*   3. **Content checksum** — an ordered canonical-JSON SHA-256 digest over the
-*      sorted intersection of source/target columns catches content drift even
-*      when counts match.
-*   4. **Enum/type-drift report** — source values outside the target column's
-*      CHECK enum. This is the EXACT class that `INSERT OR IGNORE` used to drop
-*      silently (the root cause of the ~805K-row exodus loss).
-*
-* ## Relationship to `runExodusVerify`
-*
-* `runExodusVerify` ({@link ./verify.ts}) is the exodus-specific entry point.
-* It now DELEGATES the row-count + checksum parity to this primitive (DRY —
-* T11551 AC2) and additionally surfaces the FK + enum-drift checks this module
-* adds. The digest, name-mapping, and rowid-safe ordering logic that the exodus
-* campaign hardened (T11531/32/33) live here as the single implementation.
-*
-* ## False-pass guard (T11531, preserved)
-*
-* When `ok === false`, `error` is ALWAYS populated with a human-readable
-* failure summary so a caller that only checks `result.error` cannot mistake a
-* silent loss for success.
-*
-* @task T11551 (DHQ-045 — exodus zero-loss durable guard)
-* @epic T10878
-* @saga T11242
-*/
-var log = getLogger("verify-migration");
-var _require = createRequire(import.meta.url);
-/**
-* Determine a deterministic ORDER BY clause for a table.
-*
-* Uses the table's declared primary-key columns (from `PRAGMA table_info`
-* where `pk > 0`) so ordering is stable for both WITH ROWID and WITHOUT ROWID
-* tables. Falls back to `rowid` only for ordinary tables that declare no
-* explicit primary key. Avoids the `no such column: rowid` crash on virtual /
-* WITHOUT ROWID tables (T11532 ROOT CAUSE 3).
-*
-* @param db        - Database handle to introspect.
-* @param tableName - Physical table name.
-* @returns A SQL ORDER BY column list.
-*/
-function orderByClause(db, tableName) {
-	try {
-		const pkCols = db.prepare(`PRAGMA table_info("${tableName}")`).all().filter((r) => r.pk > 0).sort((a, b) => a.pk - b.pk).map((r) => `"${r.name}"`);
-		if (pkCols.length > 0) return pkCols.join(", ");
-	} catch {}
-	return "rowid";
-}
-/**
-* Compute an ordered canonical-JSON SHA-256 digest (32 hex chars) for all rows
-* in a table, restricted to the given column list.
-*
-* When the caller passes the SORTED INTERSECTION of source and target columns,
-* both sides produce identically-structured JSON rows, eliminating spurious
-* hash mismatches from schema-definition column reordering (T11533 ROOT CAUSE
-* 4). Returns `{ count: 0, hash: '' }` for virtual tables that cannot be
-* selected from, rather than throwing.
-*
-* ## Source-side coercion (T11809 · AC2)
-*
-* When `transform` is provided (SOURCE side only), each column is SELECTed
-* through {@link buildDigestExpr} — the SAME epoch→ISO / enum-normalize /
-* non-finite-clamp transforms the migration applied — and aliased back to its
-* original name so the canonical-key serialisation matches the (already
-* canonical) target row. The TARGET side passes `transform === undefined` and
-* digests its stored values raw.
-*
-* @param db         - Database handle to query.
-* @param tableName  - Physical table name.
-* @param columns    - Explicit column list in canonical order, or `null` for
-*   `SELECT *` (used when there is no counterpart table to intersect with).
-* @param transform  - Source-side transform spec, or `undefined` for the raw
-*   (target-side) digest.
-* @returns `{ count, hash }` for the table.
-*/
-function computeTableDigest(db, tableName, columns, transform) {
-	let count = 0;
-	try {
-		const row = db.prepare(`SELECT COUNT(*) AS c FROM "${tableName}"`).get();
-		count = Number(row?.c ?? 0);
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		log.warn({
-			tableName,
-			err: msg
-		}, "computeTableDigest: COUNT(*) failed (possibly a virtual/FTS table) — treating as 0 rows");
-		return {
-			count: 0,
-			hash: ""
-		};
-	}
-	const { createHash } = _require("node:crypto");
-	const hasher = createHash("sha256");
-	const orderBy = orderByClause(db, tableName);
-	let selectClause;
-	if (columns !== null && columns.length > 0) selectClause = columns.map((c) => {
-		if (transform === void 0) return `"${c}"`;
-		const srcType = transform.srcTypeByCol.get(c) ?? "";
-		const tgtCol = transform.tgtColByCol.get(c);
-		return `${buildDigestExpr(transform.targetTableName, c, srcType, transform.isoGlobCols, tgtCol)} AS "${c}"`;
-	}).join(", ");
-	else selectClause = "*";
-	try {
-		const stmt = db.prepare(`SELECT ${selectClause} FROM "${tableName}" ORDER BY ${orderBy}`);
-		for (const row of stmt.iterate()) {
-			const rowObj = row;
-			hasher.update(JSON.stringify(rowObj, Object.keys(rowObj).sort()));
-		}
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		log.warn({
-			tableName,
-			err: msg
-		}, "computeTableDigest: streamed SELECT failed (possibly a virtual/FTS table) — digest skipped (COUNT(*) parity still enforced)");
-		return {
-			count,
-			hash: ""
-		};
-	}
-	return {
-		count,
-		hash: hasher.digest("hex").slice(0, 32)
-	};
-}
-/**
-* Return the sorted intersection of column names present in both the source and
-* target tables, for use as the canonical column ordering in
-* {@link computeTableDigest}. Returns `null` when either side has no columns
-* (virtual/FTS-table fallback).
-*
-* @param srcDb    - Source database handle.
-* @param srcTable - Physical table name in the source DB.
-* @param tgtDb    - Target database handle.
-* @param tgtTable - Physical table name in the target DB.
-*/
-function sharedColumnsSorted(srcDb, srcTable, tgtDb, tgtTable) {
-	try {
-		const srcCols = srcDb.prepare(`PRAGMA table_info("${srcTable}")`).all().map((r) => r.name);
-		const tgtColSet = new Set(tgtDb.prepare(`PRAGMA table_info("${tgtTable}")`).all().map((r) => r.name));
-		if (srcCols.length === 0 || tgtColSet.size === 0) return null;
-		return srcCols.filter((c) => tgtColSet.has(c)).sort();
-	} catch {
-		return null;
-	}
-}
-/**
-* Build the source-side {@link DigestTransformSpec} for a source→target table
-* pair: the source column type affinities, the target's ISO-GLOB columns, and
-* the target column metadata (NOT-NULL flag + default + affinity), keyed by the
-* consolidated target name (the transform lookup key). The target metadata
-* drives the NULL→NOT-NULL-default `COALESCE` mirroring (T11836).
-*
-* Returns `undefined` (raw digest, no transform) when the source `PRAGMA
-* table_info` cannot be read — best-effort, biased to surfacing a real
-* difference rather than masking one.
-*
-* @param srcDb           - Source database handle.
-* @param srcTable        - Physical legacy source table name.
-* @param tgtDb           - Target database handle (consolidated cleo.db).
-* @param targetTableName - Physical consolidated target table name.
-* @returns A transform spec, or `undefined` when source metadata is unavailable.
-*/
-function buildSourceDigestTransform(srcDb, srcTable, tgtDb, targetTableName) {
-	try {
-		return {
-			targetTableName,
-			srcTypeByCol: new Map(srcDb.prepare(`PRAGMA table_info("${srcTable}")`).all().map((r) => [r.name, r.type])),
-			isoGlobCols: detectIsoGlobColumns(tgtDb, targetTableName),
-			tgtColByCol: new Map(tgtDb.prepare(`PRAGMA table_info("${targetTableName}")`).all().map((r) => [r.name, {
-				notnull: r.notnull,
-				dflt_value: r.dflt_value,
-				type: r.type
-			}]))
-		};
-	} catch {
-		return;
-	}
-}
-/**
-* List user tables in a DB (excluding SQLite internals + Drizzle journal).
-*/
-function listTables(db) {
-	return db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%' ORDER BY name").all().map((r) => r.name);
-}
-/**
-* Return `true` if `tableName` exists in `db`. Used to route an FK-orphan row to
-* the scope DB that actually declares its child table (T11572).
-*/
-function tableExists(db, tableName) {
-	try {
-		const escaped = tableName.replace(/'/g, "''");
-		return db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='${escaped}'`).get() !== void 0;
-	} catch {
-		return false;
-	}
-}
-/**
-* Regex that extracts a single-column `IN (...)` CHECK enum from a table's DDL.
-*
-* Matches the canonical Drizzle-generated form:
-*   `CHECK ("col" IN ('a', 'b', 'c'))`
-* and the NULL-tolerant variant:
-*   `CHECK ("col" IS NULL OR "col" IN ('a', 'b'))`
-*
-* Capture group 1 is the column name; group 2 is the raw `'a', 'b', …` list.
-* The regex is intentionally conservative — it only recognises the
-* string-literal `IN` enum shape (the one that drops rows on drift), not GLOB
-* or arithmetic CHECKs.
-*/
-var CHECK_ENUM_REGEX = /CHECK\s*\(\s*"([^"]+)"\s+(?:IS\s+NULL\s+OR\s+"[^"]+"\s+)?IN\s*\(([^)]*)\)\s*\)/gi;
-/**
-* Parse the `'a', 'b', 'c'` body of an `IN (...)` clause into the set of
-* canonical enum members (single-quoted SQL string literals, `''` un-escaped).
-*/
-function parseEnumMembers(body) {
-	const members = [];
-	for (const m of body.matchAll(/'((?:[^']|'')*)'/g)) members.push(m[1].replace(/''/g, "'"));
-	return members;
-}
-/**
-* Read a target table's DDL and return a map of `column → allowed enum members`
-* for every single-column string-literal CHECK enum on that table.
-*
-* @param db        - Target DB with the consolidated schema.
-* @param tableName - Physical consolidated table name.
-* @returns Map from column name to its allowed enum members. Empty when the
-*   table declares no recognised CHECK enums.
-*/
-function detectCheckEnums(db, tableName) {
-	const escaped = tableName.replace(/'/g, "''");
-	const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='${escaped}'`).get();
-	const out = /* @__PURE__ */ new Map();
-	if (!row?.sql) return out;
-	CHECK_ENUM_REGEX.lastIndex = 0;
-	for (const match of row.sql.matchAll(CHECK_ENUM_REGEX)) {
-		const col = match[1];
-		const members = parseEnumMembers(match[2]);
-		if (members.length > 0) out.set(col, members);
-	}
-	return out;
-}
-/**
-* Detect enum/type drift for one source→target table pair: source values in an
-* enum-constrained column that are NOT members of the target CHECK enum.
-*
-* Reads the DISTINCT non-null values of each enum column from the source table
-* and compares them against the target's allowed members. Only columns present
-* in BOTH source and target are inspected. The check is purely diagnostic — it
-* reports raw source drift; the migration layer is responsible for normalising
-* known aliases before insert.
-*
-* @param srcDb        - Source DB handle.
-* @param srcTable     - Physical source table name.
-* @param tgtDb        - Target DB handle.
-* @param tgtTable     - Physical consolidated target table name.
-* @returns Drift findings for this table (empty when fully canonical).
-*/
-function detectTableEnumDrift(srcDb, srcTable, tgtDb, tgtTable) {
-	const enums = detectCheckEnums(tgtDb, tgtTable);
-	if (enums.size === 0) return [];
-	let srcCols;
-	try {
-		srcCols = new Set(srcDb.prepare(`PRAGMA table_info("${srcTable}")`).all().map((r) => r.name));
-	} catch {
-		return [];
-	}
-	const findings = [];
-	for (const [col, allowed] of enums) {
-		if (!srcCols.has(col)) continue;
-		const allowedSet = new Set(allowed);
-		let rows;
-		try {
-			rows = srcDb.prepare(`SELECT "${col}" AS v, COUNT(*) AS c FROM "${srcTable}" WHERE "${col}" IS NOT NULL GROUP BY "${col}"`).all();
-		} catch {
-			continue;
-		}
-		const offending = [];
-		let driftCount = 0;
-		for (const r of rows) {
-			const value = String(r.v);
-			if (!allowedSet.has(value)) {
-				driftCount += r.c;
-				if (offending.length < 20) offending.push(value);
-			}
-		}
-		if (driftCount > 0) findings.push({
-			targetTable: tgtTable,
-			column: col,
-			offendingValues: offending,
-			allowedValues: allowed,
-			driftCount
-		});
-	}
-	return findings;
-}
-/**
-* Run `PRAGMA foreign_key_check` on a target DB and return any orphan rows.
-*
-* @param db    - Target DB handle (consolidated cleo.db).
-* @param scope - Scope label, attached to log context only.
-* @returns The list of FK violations (empty when referential integrity holds).
-*/
-function foreignKeyCheck(db, scope) {
-	try {
-		const rows = db.prepare("PRAGMA foreign_key_check").all();
-		if (rows.length > 0) log.warn({
-			scope,
-			count: rows.length,
-			sample: rows.slice(0, 5)
-		}, `verifyMigration: PRAGMA foreign_key_check found ${rows.length} orphan row(s)`);
-		return rows.map((r) => ({
-			table: r.table,
-			rowid: r.rowid ?? null,
-			parent: r.parent,
-			fkid: r.fkid
-		}));
-	} catch (err) {
-		log.warn({
-			scope,
-			err
-		}, "verifyMigration: PRAGMA foreign_key_check failed (non-fatal)");
-		return [];
-	}
-}
-/**
-* Compute a **migration-stable, name-mapping-stable signature** for one FK
-* orphan so the same dangling row can be matched between the legacy SOURCE and
-* the consolidated TARGET — despite (a) a different `rowid` after the copy AND
-* (b) the legacy→consolidated table RENAME (`task_relations`→`tasks_task_relations`,
-* parent `tasks`→`tasks_tasks`).
-*
-* `PRAGMA foreign_key_check` returns `{ table, rowid, parent, fkid }`. We key the
-* orphan on:
-*   - the CONSOLIDATED child-table name (source names are mapped via
-*     {@link resolveConsolidatedTableName} so both sides agree),
-*   - the CONSOLIDATED parent-table name (same mapping),
-*   - the actual VALUES of the foreign-key child columns for that row (read via
-*     `PRAGMA foreign_key_list` + the row at `rowid`) — these travel with the row
-*     unchanged, so the dangling reference is identical on both sides.
-*
-* `fkid` is intentionally EXCLUDED — the consolidated table may declare its FKs
-* in a different order than the legacy one, so the per-table fkid is not stable.
-* The (consolidated child, consolidated parent, dangling FK column values) triple
-* uniquely identifies the orphan reference.
-*
-* Falls back to a column-name-only shape if the child columns can't be read
-* (best-effort — a fallback only ever makes two orphans compare as *different*,
-* which biases toward treating an orphan as "introduced", the SAFE/strict
-* direction).
-*
-* @param db         - DB handle the orphan was found in.
-* @param v          - One `PRAGMA foreign_key_check` row.
-* @param sourceName - When set, the orphan is on the SOURCE side and its
-*   `table`/`parent` names are mapped to their consolidated equivalents so the
-*   signature matches the target side. Omit for the already-consolidated target.
-* @returns A stable string signature.
-*/
-function orphanSignature(db, v, sourceName) {
-	const mapName = (name) => {
-		if (sourceName === void 0) return name;
-		const res = resolveConsolidatedTableName(sourceName, name);
-		return res.kind === "skip" ? name : res.targetName;
-	};
-	const childTable = mapName(v.table);
-	const parentTable = mapName(v.parent);
-	let childCols = [];
-	try {
-		childCols = db.prepare(`PRAGMA foreign_key_list("${v.table}")`).all().filter((r) => r.id === v.fkid).map((r) => r.from);
-	} catch {}
-	if (v.rowid !== null && childCols.length > 0) try {
-		const sel = childCols.map((c) => `"${c}"`).join(", ");
-		const row = db.prepare(`SELECT ${sel} FROM "${v.table}" WHERE rowid = ?`).get(v.rowid);
-		if (row) return `${childTable}|${parentTable}|${childCols.slice().sort().map((c) => `${c}=${JSON.stringify(row[c])}`).join("&")}`;
-	} catch {}
-	return `${childTable}|${parentTable}|rowid:${v.rowid ?? "?"}`;
-}
-/**
-* Collect the set of {@link orphanSignature}s for every FK orphan in a SOURCE DB.
-*
-* Used to compute SOURCE-side orphan signatures so the parity gate can subtract
-* pre-existing orphans from the target's orphan set and fail only on the orphans
-* the migration INTRODUCED (T11572). The signatures are mapped to consolidated
-* table names so they compare equal to the target-side signatures.
-*
-* @param db         - SOURCE DB handle to scan.
-* @param sourceName - `LegacyDbDescriptor.name` (for table-name mapping).
-* @param scope      - Scope label for diagnostics.
-* @returns A set of name-mapping-stable orphan signatures.
-*/
-function sourceOrphanSignatures(db, sourceName, scope) {
-	const sigs = /* @__PURE__ */ new Set();
-	try {
-		const rows = db.prepare("PRAGMA foreign_key_check").all();
-		for (const r of rows) sigs.add(orphanSignature(db, r, sourceName));
-		if (rows.length > 0) log.warn({
-			scope,
-			count: rows.length,
-			sample: rows.slice(0, 5)
-		}, `verifyMigration: source already has ${rows.length} pre-existing FK orphan(s) — these are tolerated (carried forward losslessly, flagged for data-hygiene)`);
-	} catch (err) {
-		log.warn({
-			scope,
-			err
-		}, "verifyMigration: source PRAGMA foreign_key_check failed (non-fatal)");
-	}
-	return sigs;
-}
-/**
-* Verify that a source→target SQLite migration preserved every row, referential
-* integrity, content, and enum validity.
-*
-* Opens all source DBs and the consolidated target DBs **read-only**, then for
-* each legacy source table:
-*
-*   1. Resolves the consolidated target name via {@link resolveConsolidatedTableName}.
-*   2. Compares row counts (parity gate).
-*   3. Computes a column-intersection content digest on both sides.
-*   4. Records any enum/type drift (source values outside the target CHECK enum).
-*
-* After all tables, it runs `PRAGMA foreign_key_check` on each distinct target
-* DB and folds the orphan rows into the result.
-*
-* @param sources       - Legacy source descriptors (from `buildExodusPlan()`).
-* @param projectDbPath - Absolute path to the consolidated project `cleo.db`.
-* @param globalDbPath  - Absolute path to the consolidated global `cleo.db`.
-* @param onProgress    - Optional progress callback.
-*
-* @returns A {@link VerifyMigrationResult}. `ok === false` (with `error`
-*   populated) on any count mismatch, content mismatch, FK orphan, or enum
-*   drift.
-*
-* @task T11551 (DHQ-045 — exodus zero-loss durable guard · AC1)
-*/
-function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
-	const tables = [];
-	const enumDrift = [];
-	const foreignKeyViolations = [];
-	const introducedForeignKeyViolations = [];
-	const preExistingForeignKeyViolations = [];
-	const failureLines = [];
-	/**
-	* Signatures of FK orphans ALREADY present in the legacy SOURCE DBs (T11572).
-	* Target orphans whose signature is in this set are pre-existing — carried
-	* forward losslessly — and do NOT fail the parity gate.
-	*/
-	const sourceOrphanSigs = /* @__PURE__ */ new Set();
-	if (!existsSync(projectDbPath)) return {
-		ok: false,
-		tables: [],
-		foreignKeyViolations: [],
-		introducedForeignKeyViolations: [],
-		preExistingForeignKeyViolations: [],
-		enumDrift: [],
-		error: `Consolidated project cleo.db not found at ${projectDbPath}. Run 'cleo exodus migrate' first.`
-	};
-	if (!existsSync(globalDbPath)) return {
-		ok: false,
-		tables: [],
-		foreignKeyViolations: [],
-		introducedForeignKeyViolations: [],
-		preExistingForeignKeyViolations: [],
-		enumDrift: [],
-		error: `Consolidated global cleo.db not found at ${globalDbPath}. Run 'cleo exodus migrate' first.`
-	};
-	const projectSnap = openCleoDbSnapshot(projectDbPath, { readOnly: true });
-	const globalSnap = openCleoDbSnapshot(globalDbPath, { readOnly: true });
-	try {
-		for (const src of sources) {
-			if (!existsSync(src.path)) {
-				onProgress?.(`Skipping ${src.name} (not present)`);
-				continue;
-			}
-			const srcSnap = openCleoDbSnapshot(src.path, { readOnly: true });
-			try {
-				for (const sig of sourceOrphanSignatures(srcSnap.db, src.name, `source:${src.name}`)) sourceOrphanSigs.add(sig);
-				const sourceTables = listTables(srcSnap.db);
-				const projectTables = new Set(listTables(projectSnap.db));
-				const globalTables = new Set(listTables(globalSnap.db));
-				for (const legacyTableName of sourceTables) {
-					onProgress?.(`Verifying ${src.name}.${legacyTableName}…`);
-					const resolution = resolveConsolidatedTableName(src.name, legacyTableName);
-					if (resolution.kind === "skip") {
-						onProgress?.(`  [skip] ${src.name}.${legacyTableName} — ${resolution.reason}`);
-						continue;
-					}
-					const targetTableName = resolution.targetName;
-					const scope = resolveTableTargetScope(src.name, legacyTableName, src.targetScope);
-					const targetSnap = scope === "project" ? projectSnap : globalSnap;
-					const targetTables = scope === "project" ? projectTables : globalTables;
-					if (targetTables.has(targetTableName)) {
-						const drift = detectTableEnumDrift(srcSnap.db, legacyTableName, targetSnap.db, targetTableName);
-						if (drift.length > 0) {
-							enumDrift.push(...drift);
-							for (const d of drift) failureLines.push(`[${scope}] ${targetTableName}.${d.column}: ${d.driftCount} row(s) with value(s) outside enum {${d.allowedValues.join(", ")}} — e.g. ${d.offendingValues.map((v) => `'${v}'`).join(", ")}`);
-						}
-					}
-					if (!targetTables.has(targetTableName)) {
-						const srcResult = computeTableDigest(srcSnap.db, legacyTableName, null);
-						const countMatch = srcResult.count === 0;
-						tables.push({
-							sourceTable: legacyTableName,
-							targetTable: targetTableName,
-							scope,
-							sourceCount: srcResult.count,
-							targetCount: 0,
-							sourceHash: srcResult.hash,
-							targetHash: "",
-							hashMatch: countMatch,
-							countMatch
-						});
-						if (!countMatch) failureLines.push(`[${scope}] ${src.name}.${legacyTableName} → ${targetTableName}: missing from target (source has ${srcResult.count} rows)`);
-						continue;
-					}
-					const cols = sharedColumnsSorted(srcSnap.db, legacyTableName, targetSnap.db, targetTableName);
-					const srcTransform = buildSourceDigestTransform(srcSnap.db, legacyTableName, targetSnap.db, targetTableName);
-					const srcDigest = computeTableDigest(srcSnap.db, legacyTableName, cols, srcTransform);
-					const tgtDigest = computeTableDigest(targetSnap.db, targetTableName, cols);
-					const countMatch = srcDigest.count === tgtDigest.count;
-					const hashMatch = srcDigest.hash === tgtDigest.hash;
-					if (tgtDigest.count < srcDigest.count) failureLines.push(`[${scope}] ${src.name}.${legacyTableName} → ${targetTableName}: DEFICIT — source=${srcDigest.count} rows, target=${tgtDigest.count} rows (${srcDigest.count - tgtDigest.count} missing), hashMatch=${hashMatch}`);
-					else if (tgtDigest.count > srcDigest.count) log.warn({
-						scope,
-						source: src.name,
-						table: targetTableName,
-						sourceCount: srcDigest.count,
-						targetCount: tgtDigest.count,
-						delta: tgtDigest.count - srcDigest.count
-					}, `verifyMigration: ${targetTableName} has ${tgtDigest.count - srcDigest.count} MORE row(s) in target than source (surplus — NOT data loss, tolerated; e.g. migration-time audit writes). Verify it is not an unexpected double-copy.`);
-					else if (!hashMatch) failureLines.push(`[${scope}] ${src.name}.${legacyTableName} → ${targetTableName}: source=${srcDigest.count} rows, target=${tgtDigest.count} rows, hashMatch=${hashMatch}`);
-					tables.push({
-						sourceTable: legacyTableName,
-						targetTable: targetTableName,
-						scope,
-						sourceCount: srcDigest.count,
-						targetCount: tgtDigest.count,
-						sourceHash: srcDigest.hash,
-						targetHash: tgtDigest.hash,
-						hashMatch,
-						countMatch
-					});
-				}
-			} finally {
-				srcSnap.close();
-			}
-		}
-		const targetOrphans = [];
-		targetOrphans.push(...foreignKeyCheck(projectSnap.db, "project"));
-		targetOrphans.push(...foreignKeyCheck(globalSnap.db, "global"));
-		foreignKeyViolations.push(...targetOrphans);
-		for (const fk of targetOrphans) {
-			const sig = orphanSignature(tableExists(projectSnap.db, fk.table) ? projectSnap.db : globalSnap.db, fk);
-			if (sourceOrphanSigs.has(sig)) preExistingForeignKeyViolations.push(fk);
-			else {
-				introducedForeignKeyViolations.push(fk);
-				failureLines.push(`[fk] ${fk.table}.rowid=${fk.rowid ?? "?"} references missing ${fk.parent} (fkid=${fk.fkid}) — INTRODUCED by migration`);
-			}
-		}
-		if (preExistingForeignKeyViolations.length > 0) log.warn({
-			count: preExistingForeignKeyViolations.length,
-			sample: preExistingForeignKeyViolations.slice(0, 5)
-		}, `verifyMigration: ${preExistingForeignKeyViolations.length} pre-existing source FK orphan(s) carried forward losslessly — tolerated (flag for data-hygiene follow-up, NOT a migration failure)`);
-	} catch (err) {
-		const error = err instanceof Error ? err.message : String(err);
-		log.error({ err }, "verifyMigration failed");
-		return {
-			ok: false,
-			tables,
-			foreignKeyViolations,
-			introducedForeignKeyViolations,
-			preExistingForeignKeyViolations,
-			enumDrift,
-			error
-		};
-	} finally {
-		projectSnap.close();
-		globalSnap.close();
-	}
-	if (failureLines.length > 0) {
-		const error = `verifyMigration FAILED: ${failureLines.length} issue(s):\n${failureLines.map((l) => `  • ${l}`).join("\n")}`;
-		log.error({ failureCount: failureLines.length }, error);
-		return {
-			ok: false,
-			tables,
-			foreignKeyViolations,
-			introducedForeignKeyViolations,
-			preExistingForeignKeyViolations,
-			enumDrift,
-			error
-		};
-	}
-	return {
-		ok: true,
-		tables,
-		foreignKeyViolations,
-		introducedForeignKeyViolations,
-		preExistingForeignKeyViolations,
-		enumDrift
-	};
-}
-
-export { buildExodusPlan, clearExodusJournal, runExodusMigrate, verifyMigration };
-//# sourceMappingURL=exodus-BBuuN6aA.js.map